@apso/cli 0.3.0 → 0.4.0

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

@@ -10,13 +10,13 @@ export default class New extends BaseCommand {
     static args: {
         name: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
     };
-    installModules(path: string): Promise<void>;
-    formatApp(root: string): Promise<void>;
-    startApp(root: string): Promise<void>;
+    installModules(projectPath: string): Promise<void>;
+    formatApp(projectPath: string): Promise<void>;
+    startApp(projectPath: string): Promise<void>;
     cloneTemplate(projectPath: string): Promise<void>;
-    run(): Promise<void>;
     validateFlags(): Promise<{
         projectName: string;
         apiType: string;
     }>;
+    run(): Promise<void>;
 }

package/dist/commands/server/new.js

@@ -12,28 +12,25 @@ class New extends base_command_1.default {
         super(...arguments);
         this.CURR_DIR = process.cwd();
     }
-    async installModules(path) {
-        this.log("installing modules");
-        await this.runNpmCommand(["install", "--force", "--prefix", path]);
+    async installModules(projectPath) {
+        this.log("Installing modules...");
+        await this.runNpmCommand(["install", "--force", "--prefix", projectPath]);
     }
-    async formatApp(root) {
-        this.log("cleaning up");
-        shelljs_1.default.cd(root);
-        await this.runNpmCommand(["run", "format", "--prefix", root]);
+    async formatApp(projectPath) {
+        this.log("Formatting code...");
+        shelljs_1.default.cd(projectPath);
+        await this.runNpmCommand(["run", "format", "--prefix", projectPath]);
     }
-    async startApp(root) {
+    async startApp(projectPath) {
         return new Promise((resolve, reject) => {
-            const command = "npm";
+            const isWindows = process.platform === "win32";
+            const command = isWindows ? "npm.cmd" : "npm";
             const args = ["start"];
-            // Explicitly set cwd() to work around issues like
-            // https://github.com/facebook/create-react-app/issues/3326.
-            // Unfortunately we can only do this for Yarn because npm support for
-            // equivalent --prefix flag doesn't help with this issue.
-            // This is why for npm, we run checkThatNpmCanReadCwd() early instead.
-            // args.push('--cwd')
-            // args.push(root)
-            // args.push('--verbose')
-            const child = (0, child_process_1.spawn)(command, args, { stdio: "inherit", cwd: root });
+            const child = (0, child_process_1.spawn)(command, args, {
+                cwd: projectPath,
+                stdio: "inherit",
+                shell: isWindows,
+            });
             child.on("close", (code) => {
                 if (code !== 0) {
                     reject({
@@ -43,15 +40,18 @@ class New extends base_command_1.default {
                 }
                 resolve();
             });
+            child.on("error", (err) => {
+                this.log(`Error starting app: ${err.message}`);
+                reject(err);
+            });
         });
     }
     async cloneTemplate(projectPath) {
-        this.log("Creating project in current folder.");
+        this.log("Cloning service template...");
         if (!fs.existsSync(projectPath) && this.CURR_DIR !== projectPath) {
             fs.mkdirSync(projectPath);
         }
         shelljs_1.default.cd(projectPath);
-        // Execute git clone and capture the result using HTTPS
         const cloneResult = shelljs_1.default.exec(`git clone --depth=1 --branch=main https://github.com/apsoai/service-template.git ${projectPath}`, { silent: true }); // Use silent: true to suppress default output
         // Check if the command failed
         if (cloneResult.code !== 0) {
@@ -66,34 +66,31 @@ class New extends base_command_1.default {
         shelljs_1.default.exec(`rm -rf ${projectPath}/.git`);
         shelljs_1.default.cd(this.CURR_DIR);
     }
-    async run() {
-        this.log("Initializing New Apso Server...");
-        const { projectName,
-        // apiType,
-         } = await this.validateFlags();
-        const CURR_DIR = process.cwd();
-        const projectPath = path.join(CURR_DIR, projectName);
-        await this.cloneTemplate(projectPath);
-        await this.installModules(projectPath);
-        await this.formatApp(projectPath);
-    }
     async validateFlags() {
         var _a;
         const { flags } = await this.parse(New);
         let projectName = flags.name;
         let apiType = (_a = flags.type) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-        if (typeof projectName === "undefined") {
-            // this.error("`name` must be set (e.g. WoofyApp)");
+        if (!projectName) {
             projectName = '';
         }
-        if (typeof apiType === "undefined") {
+        if (!apiType) {
             apiType = "rest";
         }
-        if (apiType !== "rest" && apiType !== "graphql") {
-            this.error("`apiType` must be set (e.g. rest or graphql)");
+        if (!["rest", "graphql"].includes(apiType)) {
+            this.error("`apiType` must be 'rest' or 'graphql'");
         }
         return { projectName, apiType };
     }
+    async run() {
+        this.log("Initializing New Apso Server...");
+        const { projectName } = await this.validateFlags();
+        const CURR_DIR = process.cwd();
+        const projectPath = path.join(CURR_DIR, projectName);
+        await this.cloneTemplate(projectPath);
+        await this.installModules(projectPath);
+        await this.formatApp(projectPath);
+    }
 }
 New.description = "Initialize your server project";
 New.examples = [`$ apso server new --name TestProject`];

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

@@ -1,23 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
 const child_process_1 = require("child_process");
+const os_1 = tslib_1.__importDefault(require("os"));
 class BaseCommand extends core_1.Command {
     async runNpmCommand(args, silent = false) {
         return new Promise((resolve, reject) => {
-            const command = "npm";
+            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(cmdStr);
-            const child = (0, child_process_1.spawn)(command, args, { stdio: silent ? "ignore" : "inherit" });
+            this.log(`Running: ${cmdStr}`);
+            const child = (0, child_process_1.spawn)(command, args, {
+                stdio,
+                shell: isWindows,
+            });
             child.on("close", (code) => {
                 if (code !== 0) {
-                    reject({
-                        command: cmdStr,
-                    });
+                    reject({ command: cmdStr, exitCode: code });
                     return;
                 }
                 resolve();
             });
+            child.on("error", () => {
+                this.error(`Failed to run: ${cmdStr}`);
+            });
         });
     }
 }

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.0",
+  "version": "0.4.0",
   "commands": {
     "server:new": {
       "id": "server:new",

package/package.json

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