@apso/cli 0.4.2 → 0.6.0

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

@@ -4,20 +4,20 @@ 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.describe)("UUID Entity Template Tests", () => {
     (0, globals_1.beforeAll)(() => {
         Eta.configure({
-            views: path.join(__dirname, '../../../lib/templates'),
-            cache: false
+            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 () => {
+    (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',
+                name: "User",
+                snakeCasedName: "user",
                 createPrimaryKey: true,
-                primaryKeyType: 'uuid',
+                primaryKeyType: "uuid",
                 createdAt: true,
                 updatedAt: true,
                 columns: [],
@@ -25,25 +25,25 @@ const globals_1 = require("@jest/globals");
                 indexes: [],
                 uniques: [],
                 entitiesToImport: [],
-                apiType: 'rest',
-                importEnums: false
+                apiType: "rest",
+                importEnums: false,
             };
-            const rendered = await Eta.renderFileAsync('./entities/entity', data);
+            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()');
+            (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.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 () => {
+        (0, globals_1.it)("should render entity with serial (auto-increment) primary key", async () => {
             const data = {
-                name: 'Post',
-                snakeCasedName: 'post',
+                name: "Post",
+                snakeCasedName: "post",
                 createPrimaryKey: true,
-                primaryKeyType: 'serial',
+                primaryKeyType: "serial",
                 createdAt: true,
                 updatedAt: true,
                 columns: [],
@@ -51,22 +51,22 @@ const globals_1 = require("@jest/globals");
                 indexes: [],
                 uniques: [],
                 entitiesToImport: [],
-                apiType: 'rest',
-                importEnums: false
+                apiType: "rest",
+                importEnums: false,
             };
-            const rendered = await Eta.renderFileAsync('./entities/entity', data);
+            const rendered = await Eta.renderFileAsync("./entities/entity", data);
             // Should use @PrimaryGeneratedColumn
-            (0, globals_1.expect)(rendered).toContain('@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()');
+            (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.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 () => {
+        (0, globals_1.it)("should default to serial primary key when primaryKeyType is not specified", async () => {
             const data = {
-                name: 'Comment',
-                snakeCasedName: 'comment',
+                name: "Comment",
+                snakeCasedName: "comment",
                 createPrimaryKey: true,
                 // primaryKeyType not specified
                 createdAt: true,
@@ -76,202 +76,202 @@ const globals_1 = require("@jest/globals");
                 indexes: [],
                 uniques: [],
                 entitiesToImport: [],
-                apiType: 'rest',
-                importEnums: false
+                apiType: "rest",
+                importEnums: false,
             };
-            const rendered = await Eta.renderFileAsync('./entities/entity', data);
+            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.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 () => {
+    (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',
+                name: "Account",
+                snakeCasedName: "account",
                 createPrimaryKey: true,
-                primaryKeyType: 'serial',
+                primaryKeyType: "serial",
                 createdAt: true,
                 updatedAt: true,
                 columns: [],
                 associations: [
                     {
-                        name: 'User',
-                        type: 'ManyToOne',
-                        relationshipName: 'user',
-                        pluralizedRelationshipName: 'users',
-                        pluralizedName: 'users',
-                        camelCasedName: 'user',
-                        camelCasedId: 'userId',
-                        entityName: 'account',
+                        name: "User",
+                        type: "ManyToOne",
+                        relationshipName: "user",
+                        pluralizedRelationshipName: "users",
+                        pluralizedName: "users",
+                        camelCasedName: "user",
+                        camelCasedId: "userId",
+                        entityName: "account",
                         joinTable: false,
                         biDirectional: true,
-                        inverseSidePropertyName: 'accounts',
-                        referencedEntityPrimaryKeyType: 'uuid',
+                        inverseSidePropertyName: "accounts",
+                        referencedEntityPrimaryKeyType: "uuid",
                         nullable: false,
-                        index: false
-                    }
+                        index: false,
+                    },
                 ],
                 indexes: [],
                 uniques: [],
-                entitiesToImport: ['User'],
-                apiType: 'rest',
-                importEnums: false
+                entitiesToImport: ["User"],
+                apiType: "rest",
+                importEnums: false,
             };
-            const rendered = await Eta.renderFileAsync('./entities/entity', data);
+            const rendered = await Eta.renderFileAsync("./entities/entity", data);
             // Should have ManyToOne decorator
-            (0, globals_1.expect)(rendered).toContain('@ManyToOne(() => User');
+            (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;');
+            (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;');
+            (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.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 () => {
+        (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',
+                name: "Post",
+                snakeCasedName: "post",
                 createPrimaryKey: true,
-                primaryKeyType: 'serial',
+                primaryKeyType: "serial",
                 createdAt: true,
                 updatedAt: true,
                 columns: [],
                 associations: [
                     {
-                        name: 'User',
-                        type: 'ManyToOne',
-                        relationshipName: 'user',
-                        pluralizedRelationshipName: 'users',
-                        pluralizedName: 'users',
-                        camelCasedName: 'user',
-                        camelCasedId: 'userId',
-                        entityName: 'post',
+                        name: "User",
+                        type: "ManyToOne",
+                        relationshipName: "user",
+                        pluralizedRelationshipName: "users",
+                        pluralizedName: "users",
+                        camelCasedName: "user",
+                        camelCasedId: "userId",
+                        entityName: "post",
                         joinTable: false,
                         biDirectional: true,
-                        inverseSidePropertyName: 'posts',
-                        referencedEntityPrimaryKeyType: 'serial',
+                        inverseSidePropertyName: "posts",
+                        referencedEntityPrimaryKeyType: "serial",
                         nullable: false,
-                        index: true
-                    }
+                        index: true,
+                    },
                 ],
                 indexes: [],
                 uniques: [],
-                entitiesToImport: ['User'],
-                apiType: 'rest',
-                importEnums: false
+                entitiesToImport: ["User"],
+                apiType: "rest",
+                importEnums: false,
             };
-            const rendered = await Eta.renderFileAsync('./entities/entity', data);
+            const rendered = await Eta.renderFileAsync("./entities/entity", data);
             // Should have ManyToOne decorator
-            (0, globals_1.expect)(rendered).toContain('@ManyToOne(() => User');
+            (0, globals_1.expect)(rendered).toContain("@ManyToOne(() => User");
             // Should have index since index: true
-            (0, globals_1.expect)(rendered).toContain('@Index()');
+            (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;');
+            (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.expect)(rendered).not.toContain("userId: string;");
         });
-        (0, globals_1.it)('should handle nullable UUID foreign keys', async () => {
+        (0, globals_1.it)("should handle nullable UUID foreign keys", async () => {
             const data = {
-                name: 'Profile',
-                snakeCasedName: 'profile',
+                name: "Profile",
+                snakeCasedName: "profile",
                 createPrimaryKey: true,
-                primaryKeyType: 'uuid',
+                primaryKeyType: "uuid",
                 createdAt: true,
                 updatedAt: true,
                 columns: [],
                 associations: [
                     {
-                        name: 'Organization',
-                        type: 'ManyToOne',
-                        relationshipName: 'organization',
-                        pluralizedRelationshipName: 'organizations',
-                        pluralizedName: 'organizations',
-                        camelCasedName: 'organization',
-                        camelCasedId: 'organizationId',
-                        entityName: 'profile',
+                        name: "Organization",
+                        type: "ManyToOne",
+                        relationshipName: "organization",
+                        pluralizedRelationshipName: "organizations",
+                        pluralizedName: "organizations",
+                        camelCasedName: "organization",
+                        camelCasedId: "organizationId",
+                        entityName: "profile",
                         joinTable: false,
                         biDirectional: false,
-                        referencedEntityPrimaryKeyType: 'uuid',
+                        referencedEntityPrimaryKeyType: "uuid",
                         nullable: true,
-                        index: false
-                    }
+                        index: false,
+                    },
                 ],
                 indexes: [],
                 uniques: [],
-                entitiesToImport: ['Organization'],
-                apiType: 'rest',
-                importEnums: false
+                entitiesToImport: ["Organization"],
+                apiType: "rest",
+                importEnums: false,
             };
-            const rendered = await Eta.renderFileAsync('./entities/entity', data);
+            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.expect)(rendered).toContain("organizationId: string;");
         });
-        (0, globals_1.it)('should handle multiple relationships with mixed UUID and serial foreign keys', async () => {
+        (0, globals_1.it)("should handle multiple relationships with mixed UUID and serial foreign keys", async () => {
             const data = {
-                name: 'Comment',
-                snakeCasedName: 'comment',
+                name: "Comment",
+                snakeCasedName: "comment",
                 createPrimaryKey: true,
-                primaryKeyType: 'serial',
+                primaryKeyType: "serial",
                 createdAt: true,
                 updatedAt: true,
                 columns: [],
                 associations: [
                     {
-                        name: 'User',
-                        type: 'ManyToOne',
-                        relationshipName: 'user',
-                        pluralizedRelationshipName: 'users',
-                        pluralizedName: 'users',
-                        camelCasedName: 'user',
-                        camelCasedId: 'userId',
-                        entityName: 'comment',
+                        name: "User",
+                        type: "ManyToOne",
+                        relationshipName: "user",
+                        pluralizedRelationshipName: "users",
+                        pluralizedName: "users",
+                        camelCasedName: "user",
+                        camelCasedId: "userId",
+                        entityName: "comment",
                         joinTable: false,
                         biDirectional: true,
-                        inverseSidePropertyName: 'comments',
-                        referencedEntityPrimaryKeyType: 'uuid',
+                        inverseSidePropertyName: "comments",
+                        referencedEntityPrimaryKeyType: "uuid",
                         nullable: false,
-                        index: true
+                        index: true,
                     },
                     {
-                        name: 'Post',
-                        type: 'ManyToOne',
-                        relationshipName: 'post',
-                        pluralizedRelationshipName: 'posts',
-                        pluralizedName: 'posts',
-                        camelCasedName: 'post',
-                        camelCasedId: 'postId',
-                        entityName: 'comment',
+                        name: "Post",
+                        type: "ManyToOne",
+                        relationshipName: "post",
+                        pluralizedRelationshipName: "posts",
+                        pluralizedName: "posts",
+                        camelCasedName: "post",
+                        camelCasedId: "postId",
+                        entityName: "comment",
                         joinTable: false,
                         biDirectional: true,
-                        inverseSidePropertyName: 'comments',
-                        referencedEntityPrimaryKeyType: 'serial',
+                        inverseSidePropertyName: "comments",
+                        referencedEntityPrimaryKeyType: "serial",
                         nullable: false,
-                        index: true
-                    }
+                        index: true,
+                    },
                 ],
                 indexes: [],
                 uniques: [],
-                entitiesToImport: ['User', 'Post'],
-                apiType: 'rest',
-                importEnums: false
+                entitiesToImport: ["User", "Post"],
+                apiType: "rest",
+                importEnums: false,
             };
-            const rendered = await Eta.renderFileAsync('./entities/entity', data);
+            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;');
+            (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;');
+            (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;');
+            (0, globals_1.expect)(rendered).toContain("user: User;");
+            (0, globals_1.expect)(rendered).toContain("post: Post;");
         });
     });
 });

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

@@ -6,7 +6,7 @@ const parse_1 = require("../../lib/utils/relationships/parse");
     (0, globals_1.test)("should deduplicate ManyToMany relationships", () => {
         // Mock entity name
         const entityName = "CustomerCard";
-        // Mock relationships - simulating bidirectional ManyToMany where 
+        // 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)
@@ -16,7 +16,7 @@ const parse_1 = require("../../lib/utils/relationships/parse");
                 referenceName: "subscriptions",
                 biDirectional: true,
                 join: false,
-                inverseReferenceName: "customercards"
+                inverseReferenceName: "customercards",
             },
             // Duplicate relationship (join side) - similar to what happens in bidirectional ManyToMany
             {
@@ -25,8 +25,8 @@ const parse_1 = require("../../lib/utils/relationships/parse");
                 referenceName: "subscriptions",
                 biDirectional: true,
                 join: true,
-                inverseReferenceName: "customercards"
-            }
+                inverseReferenceName: "customercards",
+            },
         ];
         // Run the function
         const result = (0, parse_1.getRelationshipForTemplate)(entityName, mockRelationships);
@@ -47,22 +47,22 @@ const parse_1 = require("../../lib/utils/relationships/parse");
                 type: "ManyToMany",
                 referenceName: "workspaces",
                 biDirectional: true,
-                join: true
+                join: true,
             },
             {
                 name: "Workspace",
                 type: "ManyToMany",
                 referenceName: "ownedWorkspaces",
                 biDirectional: true,
-                join: 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);
+        const referenceNames = result.map((r) => r.relationshipName || r.referenceName);
         (0, globals_1.expect)(referenceNames).toContain("workspaces");
         (0, globals_1.expect)(referenceNames).toContain("ownedWorkspaces");
     });
@@ -76,15 +76,15 @@ const parse_1 = require("../../lib/utils/relationships/parse");
                 type: "ManyToMany",
                 biDirectional: true,
                 join: false,
-                referenceName: "workspaceservices"
+                referenceName: "workspaceservices",
             },
             {
                 name: "WorkspaceService",
                 type: "ManyToMany",
                 biDirectional: true,
                 join: true,
-                referenceName: "workspaceservices"
-            }
+                referenceName: "workspaceservices",
+            },
         ];
         // Run the function
         const result = (0, parse_1.getRelationshipForTemplate)(entityName, mockRelationships);

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.4.2",
+  "version": "0.6.0",
   "commands": {
     "server:new": {
       "id": "server:new",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "description": "Apso CLI",
   "author": "Apso by Mavric - @mavric",
   "bin": {