@apso/cli 0.3.1 → 0.4.0

package/dist/commands/server/scaffold.d.ts

@@ -7,7 +7,13 @@ export default class Scaffold extends BaseCommand {
         help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
     };
     static args: {};
-    scaffoldServer(dir: string, entity: Entity, relationshipMap: RelationshipMap, apiType: string): Promise<void>;
+    scaffoldServer(options: {
+        dir: string;
+        entity: Entity;
+        relationshipMap: RelationshipMap;
+        apiType: string;
+        allEntities: Entity[];
+    }): Promise<void>;
     setupRestFiles(dir: string, entity: Entity, relationshipMap: RelationshipMap, apiType: string): Promise<void>;
     setupGraphqlFiles(dir: string, entity: Entity, relationshipMap: RelationshipMap): Promise<void>;
     run(): Promise<void>;

package/dist/commands/server/scaffold.js

@@ -13,13 +13,20 @@ Eta.configure({
     cache: false
 });
 class Scaffold extends base_command_1.default {
-    async scaffoldServer(dir, entity, relationshipMap, apiType) {
+    async scaffoldServer(options) {
+        const { dir, entity, relationshipMap, apiType, allEntities } = options;
         const entityBuildStart = perf_hooks_1.performance.now();
         this.log(`Building... ${entity.name}`);
         const entityName = entity.name;
         const filePath = path.join(dir, entityName);
         const entityRelationships = relationshipMap[entity.name] || [];
-        await (0, lib_1.createEntity)(filePath, entity, entityRelationships, apiType);
+        await (0, lib_1.createEntity)({
+            apiBaseDir: filePath,
+            entity,
+            relationships: entityRelationships,
+            apiType,
+            allEntities
+        });
         switch (apiType) {
             case apsorc_parser_1.ApiType.Graphql:
                 await this.setupGraphqlFiles(dir, entity, relationshipMap);
@@ -71,7 +78,13 @@ class Scaffold extends base_command_1.default {
         await (0, lib_1.createEnums)(autogenPath, entities, lowerCaseApiType);
         await Promise.all(entities.map(async (entity) => {
             const scaffoldModel = this.scaffoldServer.bind(this);
-            await scaffoldModel(autogenPath, entity, relationshipMap, lowerCaseApiType);
+            await scaffoldModel({
+                dir: autogenPath,
+                entity,
+                relationshipMap,
+                apiType: lowerCaseApiType,
+                allEntities: entities
+            });
             if (process.env.DEBUG) {
                 const used = process.memoryUsage();
                 console.log(`[mem] heapUsed after ${entity.name}: ${(used.heapUsed / 1024 / 1024).toFixed(2)} MB`);

package/dist/lib/base-command.js

@@ -9,10 +9,11 @@ class BaseCommand extends core_1.Command {
         return new Promise((resolve, reject) => {
             const isWindows = os_1.default.platform() === "win32";
             const command = isWindows ? "npm.cmd" : "npm";
+            const stdio = silent ? "ignore" : "inherit";
             const cmdStr = `${command} ${args.join(" ")}`;
             this.log(`Running: ${cmdStr}`);
             const child = (0, child_process_1.spawn)(command, args, {
-                stdio: "inherit",
+                stdio,
                 shell: isWindows,
             });
             child.on("close", (code) => {

package/dist/lib/entity.d.ts

@@ -2,10 +2,18 @@ import { Entity, Relationship } from "./types";
 /**
  * Generates a TypeORM entity file based on the entity definition and relationships.
  *
- * @param apiBaseDir The base directory for the generated API module (e.g., 'src/autogen/users').
- * @param entity The entity definition object from the parsed .apsorc.
- * @param relationshipsNew An array of processed Relationship objects for this entity.
- * @param apiType The type of API being generated (e.g., "rest", "graphql").
+ * @param options Configuration options for entity generation
+ * @param options.apiBaseDir The base directory for the generated API module (e.g., 'src/autogen/users').
+ * @param options.entity The entity definition object from the parsed .apsorc.
+ * @param options.relationships An array of processed Relationship objects for this entity.
+ * @param options.apiType The type of API being generated (e.g., "rest", "graphql").
+ * @param options.allEntities Optional array of all entities, used to determine foreign key types.
  * @returns {Promise<void>} A promise that resolves when the entity file is created.
  */
-export declare const createEntity: (apiBaseDir: string, entity: Entity, relationshipsNew: Relationship[], apiType: string) => Promise<void>;
+export declare const createEntity: (options: {
+    apiBaseDir: string;
+    entity: Entity;
+    relationships: Relationship[];
+    apiType: string;
+    allEntities?: Entity[];
+}) => Promise<void>;

package/dist/lib/entity.js

@@ -12,13 +12,16 @@ const Eta = tslib_1.__importStar(require("eta"));
 /**
  * Generates a TypeORM entity file based on the entity definition and relationships.
  *
- * @param apiBaseDir The base directory for the generated API module (e.g., 'src/autogen/users').
- * @param entity The entity definition object from the parsed .apsorc.
- * @param relationshipsNew An array of processed Relationship objects for this entity.
- * @param apiType The type of API being generated (e.g., "rest", "graphql").
+ * @param options Configuration options for entity generation
+ * @param options.apiBaseDir The base directory for the generated API module (e.g., 'src/autogen/users').
+ * @param options.entity The entity definition object from the parsed .apsorc.
+ * @param options.relationships An array of processed Relationship objects for this entity.
+ * @param options.apiType The type of API being generated (e.g., "rest", "graphql").
+ * @param options.allEntities Optional array of all entities, used to determine foreign key types.
  * @returns {Promise<void>} A promise that resolves when the entity file is created.
  */
-const createEntity = async (apiBaseDir, entity, relationshipsNew, apiType) => {
+const createEntity = async (options) => {
+    const { apiBaseDir, entity, relationships: relationshipsNew, apiType, allEntities } = options;
     const { name, fields = [], indexes, uniques } = entity;
     const File = path.join(apiBaseDir, `${name}.entity.ts`);
     const columns = (0, field_1.getFieldForTemplate)(fields, name);
@@ -26,13 +29,15 @@ const createEntity = async (apiBaseDir, entity, relationshipsNew, apiType) => {
         .length === 0;
     const createdAt = entity.created_at;
     const updatedAt = entity.updated_at;
-    const relationships = (0, relationships_1.getRelationshipForTemplate)(name, relationshipsNew);
+    const primaryKeyType = entity.primaryKeyType || 'serial'; // Default to 'serial' if not specified
+    const relationships = (0, relationships_1.getRelationshipForTemplate)(name, relationshipsNew, allEntities);
     const entitiesToImport = (0, relationships_1.getRelationshipsForImport)(name, relationships);
     const data = {
         name,
         indexes: indexes || [],
         uniques: uniques || [],
         createPrimaryKey,
+        primaryKeyType,
         snakeCasedName: (0, casing_1.snakeCase)(name),
         createdAt,
         updatedAt,

package/dist/lib/templates/entities/entity.eta

@@ -52,8 +52,14 @@ const { CREATE, UPDATE } = CrudValidationGroups;
 export class <%= it.name %> {
 <% if (it.createPrimaryKey) { %>
     // Fields
+    <% if (it.primaryKeyType === 'uuid') { %>
+    @Column({ type: 'uuid' })
+    @PrimaryColumn()
+    id: string;
+    <% } else { %>
     @PrimaryGeneratedColumn()
     id!: number;
+    <% } %>
 <% } %>
 
 <% if (it.createdAt) { %>
@@ -95,8 +101,13 @@ export class <%= it.name %> {
         @JoinColumn({ name: '<%= assoc.camelCasedId %>' })
         <%= assoc.relationshipName %>: <%= assoc.name %>;
 
+        <% if (assoc.referencedEntityPrimaryKeyType === 'uuid') { %>
+        @Column({ type: "uuid", <% if (assoc.nullable) { %> nullable: true <% } %>})
+        <%= assoc.camelCasedId %>: string;
+        <% } else { %>
         @Column({ type: "integer", <% if (assoc.nullable) { %> nullable: true <% } %>})
         <%= assoc.camelCasedId %>: number;
+        <% } %>
 
     <% } else if (assoc.type === 'ManyToMany') { %>
 

package/dist/lib/types/entity.d.ts

@@ -6,6 +6,7 @@ export interface Entity {
     name: string;
     created_at?: boolean;
     updated_at?: boolean;
+    primaryKeyType?: 'serial' | 'uuid';
     fields?: Field[];
     indexes?: Index[];
     uniques?: Unique[];

package/dist/lib/types/relationship.d.ts

@@ -36,6 +36,7 @@ export interface RelationshipForTemplate extends Relationship {
     joinTable: boolean;
     biDirectional: boolean;
     inversePropertyName?: string;
+    referencedEntityPrimaryKeyType?: 'serial' | 'uuid';
 }
 export type RelationshipMap = {
     [key: string]: Relationship[];

package/dist/lib/utils/relationships/parse.d.ts

@@ -49,9 +49,10 @@ export declare const getRelationshipIdField: (relationship: Relationship) => str
  * Calculates additional helper properties like pluralized names and inverse property names.
  * @param entityName The name of the entity for which to generate template data.
  * @param relationships An array of Relationship objects for the given entity.
+ * @param entities Optional array of all entities, used to determine referenced entity's primary key type.
  * @returns An array of RelationshipForTemplate objects with extra properties for the template.
  */
-export declare const getRelationshipForTemplate: (entityName: string, relationships: Relationship[]) => RelationshipForTemplate[];
+export declare const getRelationshipForTemplate: (entityName: string, relationships: Relationship[], entities?: any[]) => RelationshipForTemplate[];
 /**
  * Generates all valid nested join paths for an entity, avoiding cycles and redundant paths.
  *

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

@@ -331,12 +331,20 @@ const calculateInversePropertyName = (relationship, entityName, relationshipName
  * Calculates additional helper properties like pluralized names and inverse property names.
  * @param entityName The name of the entity for which to generate template data.
  * @param relationships An array of Relationship objects for the given entity.
+ * @param entities Optional array of all entities, used to determine referenced entity's primary key type.
  * @returns An array of RelationshipForTemplate objects with extra properties for the template.
  */
-const getRelationshipForTemplate = (entityName, relationships) => {
+const getRelationshipForTemplate = (entityName, relationships, entities) => {
     if (!relationships) {
         return [];
     }
+    // Create entity map for looking up primary key types
+    const entityMap = new Map();
+    if (entities) {
+        entities.forEach(entity => {
+            entityMap.set(entity.name, entity);
+        });
+    }
     // First pass: Group by name and referenceName (more specific)
     const processedRefs = new Map();
     relationships.forEach((relationship) => {
@@ -369,6 +377,9 @@ const getRelationshipForTemplate = (entityName, relationships) => {
             (relationship.type === 'ManyToMany' || relationship.type === 'OneToMany' || relationship.type === 'OneToOne')) {
             console.info(`[APSO INFO] Using default property name '${inverseSidePropertyName}' for ${relationship.name}->${entityName}. To customize, add 'to_name' in your relationship definition.`);
         }
+        // Look up the referenced entity's primary key type
+        const referencedEntity = entityMap.get(relationship.name);
+        const referencedEntityPrimaryKeyType = (referencedEntity === null || referencedEntity === void 0 ? void 0 : referencedEntity.primaryKeyType) || 'serial'; // Default to 'serial' if not specified
         return {
             ...relationship,
             relationshipName,
@@ -381,6 +392,7 @@ const getRelationshipForTemplate = (entityName, relationships) => {
             biDirectional: relationship.biDirectional || false,
             referenceName: thisReferenceName || undefined,
             inverseSidePropertyName,
+            referencedEntityPrimaryKeyType,
         };
     });
 };

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

@@ -227,3 +227,149 @@ const parse_1 = require("./parse");
         });
     });
 });
+(0, globals_1.describe)('getRelationshipForTemplate', () => {
+    // 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)('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' },
+            ];
+            const relationships = [
+                {
+                    name: 'User',
+                    type: 'ManyToOne',
+                    referenceName: null,
+                    nullable: false,
+                    index: false,
+                },
+            ];
+            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',
+            });
+        });
+        (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' },
+            ];
+            const relationships = [
+                {
+                    name: 'User',
+                    type: 'ManyToOne',
+                    referenceName: null,
+                    nullable: false,
+                    index: false,
+                },
+            ];
+            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',
+            });
+        });
+        (0, globals_1.it)('should default referencedEntityPrimaryKeyType to serial when entity does not specify primaryKeyType', () => {
+            const entities = [
+                { name: 'User' },
+                { name: 'Post', primaryKeyType: 'serial' },
+            ];
+            const relationships = [
+                {
+                    name: 'User',
+                    type: 'ManyToOne',
+                    referenceName: null,
+                    nullable: false,
+                    index: false,
+                },
+            ];
+            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',
+            });
+        });
+        (0, globals_1.it)('should default referencedEntityPrimaryKeyType to serial when entities array is not provided', () => {
+            const relationships = [
+                {
+                    name: 'User',
+                    type: 'ManyToOne',
+                    referenceName: null,
+                    nullable: false,
+                    index: false,
+                },
+            ];
+            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',
+            });
+        });
+        (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' },
+            ];
+            const relationships = [
+                {
+                    name: 'User',
+                    type: 'ManyToOne',
+                    referenceName: null,
+                    nullable: false,
+                    index: true,
+                },
+                {
+                    name: 'Organization',
+                    type: 'ManyToOne',
+                    referenceName: null,
+                    nullable: false,
+                    index: false,
+                },
+                {
+                    name: 'Team',
+                    type: 'ManyToOne',
+                    referenceName: null,
+                    nullable: true,
+                    index: false,
+                },
+            ];
+            const result = (0, parse_1.getRelationshipForTemplate)('Post', relationships, entities);
+            (0, globals_1.expect)(result).toHaveLength(3);
+            const userRel = result.find(r => r.name === 'User');
+            (0, globals_1.expect)(userRel).toMatchObject({
+                name: 'User',
+                type: 'ManyToOne',
+                referencedEntityPrimaryKeyType: 'uuid',
+            });
+            const orgRel = result.find(r => r.name === 'Organization');
+            (0, globals_1.expect)(orgRel).toMatchObject({
+                name: 'Organization',
+                type: 'ManyToOne',
+                referencedEntityPrimaryKeyType: 'serial',
+            });
+            const teamRel = result.find(r => r.name === 'Team');
+            (0, globals_1.expect)(teamRel).toMatchObject({
+                name: 'Team',
+                type: 'ManyToOne',
+                referencedEntityPrimaryKeyType: 'uuid',
+            });
+        });
+    });
+});

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

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

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

@@ -0,0 +1,277 @@
+"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/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.1",
+  "version": "0.4.0",
   "commands": {
     "server:new": {
       "id": "server:new",

package/package.json

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