@apso/cli 0.1.4 → 0.1.6

package/dist/commands/server/scaffold.js

@@ -27,7 +27,8 @@ class Scaffold extends base_command_1.default {
     }
     async setupRestFiles(dir, entity, relationshipMap, apiType) {
         const filePath = path.join(dir, entity.name);
-        await (0, lib_1.createDto)(filePath, entity, { apiType });
+        const entityRelationships = relationshipMap[entity.name] || [];
+        await (0, lib_1.createDto)(filePath, entity, entityRelationships, { apiType });
         await (0, lib_1.createService)(filePath, entity);
         await (0, lib_1.createController)(filePath, entity, relationshipMap);
     }

package/dist/lib/dto.d.ts

@@ -4,10 +4,11 @@ import { Entity } from "./types/entity";
  *
  * @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 relationships The relationships array from the parsed .apsorc.
  * @param options Optional configuration flags.
  * @param options.apiType The type of API being generated (default: "rest").
  * @returns {Promise<void>} A promise that resolves when the DTO files are created.
  */
-export declare const createDto: (apiBaseDir: string, entity: Entity, options?: {
+export declare const createDto: (apiBaseDir: string, entity: Entity, relationships: any[], options?: {
     apiType?: string;
 }) => Promise<void>;

package/dist/lib/dto.js

@@ -13,17 +13,45 @@ const casing_1 = require("./utils/casing");
  *
  * @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 relationships The relationships array from the parsed .apsorc.
  * @param options Optional configuration flags.
  * @param options.apiType The type of API being generated (default: "rest").
  * @returns {Promise<void>} A promise that resolves when the DTO files are created.
  */
-const createDto = async (apiBaseDir, entity, options) => {
+const createDto = async (apiBaseDir, entity, relationships, // Relationship[]
+options) => {
     var _a;
-    const { name: entityName, fields = [], associations } = entity;
-    const dtoDir = path.join(apiBaseDir, "dto");
+    const { name: entityName, fields = [] } = entity;
+    const dtoDir = path.join(apiBaseDir, "dtos");
     const dtoFile = path.join(dtoDir, `${entityName}.dto.ts`);
     const columns = (0, field_1.getFieldForTemplate)(fields, entityName);
-    const relationshipsTemplate = (0, relationships_1.getRelationshipForTemplate)(entityName, associations || []);
+    const relationshipsTemplate = (0, relationships_1.getRelationshipForTemplate)(entityName, relationships);
+    if (process.env.DEBUG) {
+        console.log('[DTO DEBUG] Generating DTO for:', entityName);
+        console.log('[DTO DEBUG] relationshipsTemplate:', relationshipsTemplate);
+    }
+    // Add foreign key columns for ManyToOne relationships if not present
+    relationshipsTemplate.forEach(rel => {
+        if (rel.type === 'ManyToOne') {
+            const fkName = (0, casing_1.camelCase)(rel.referenceName || rel.name) + 'Id';
+            if (process.env.DEBUG) {
+                console.log('[DTO DEBUG]', {
+                    relType: rel.type,
+                    relName: rel.name,
+                    referenceName: rel.referenceName,
+                    fkName,
+                    columns: columns.map(c => c.name)
+                });
+            }
+            if (!columns.some(col => col.name === fkName)) {
+                columns.push({
+                    name: fkName,
+                    dataType: 'number',
+                    type: 'integer',
+                });
+            }
+        }
+    });
     const primaryKeyColumns = columns.filter((column) => column.primary === true);
     const addDefaultPKProperty = primaryKeyColumns.length === 0;
     const createdAt = entity.created_at;
@@ -31,8 +59,8 @@ const createDto = async (apiBaseDir, entity, options) => {
     // Filter columns: remove id, createdAt, updatedAt
     const dtoColumns = columns.filter((col) => !["id", "createdAt", "updatedAt"].includes(col.name));
     // Class names
-    const createDtoName = `Create${(0, casing_1.camelCase)(entityName, true)}Dto`;
-    const updateDtoName = `Update${(0, casing_1.camelCase)(entityName, true)}Dto`;
+    const createDtoName = `Create${(0, casing_1.pascalCase)(entityName)}Dto`;
+    const updateDtoName = `Update${(0, casing_1.pascalCase)(entityName)}Dto`;
     const data = {
         entityName,
         addDefaultPKProperty,

package/dist/lib/entity.js

@@ -36,7 +36,7 @@ const createEntity = async (apiBaseDir, entity, relationshipsNew, apiType) => {
         snakeCasedName: (0, casing_1.snakeCase)(name),
         createdAt,
         updatedAt,
-        pluralizedName: (0, pluralize_1.default)((0, casing_1.camelCase)(name)),
+        pluralizedName: (0, casing_1.camelCase)((0, pluralize_1.default)(name)),
         columns,
         associations: [...new Set(relationships)],
         entitiesToImport,

package/dist/lib/gql-dto.js

@@ -27,7 +27,7 @@ const createGqlDTO = async (apiBaseDir, entity, relationshipsNew) => {
         snakeCasedName: (0, casing_1.snakeCase)(name),
         createdAt,
         updatedAt,
-        pluralizedName: (0, pluralize_1.default)((0, casing_1.camelCase)(name)),
+        pluralizedName: (0, casing_1.camelCase)((0, pluralize_1.default)(name)),
         columns,
         associations: relationships,
         entitiesToImport,

package/dist/lib/templates/entities/entity-col-json.eta

@@ -1,5 +1,5 @@
 <% const {field} = it; %>
 
-@Column('json', { nullable: <%= Boolean(field.nullable) %> })
+@Column('jsonb', { nullable: <%= Boolean(field.nullable) %> })
 
 <%= field.name %>: JSON;

package/dist/lib/templates/rest/dto-rest.eta

@@ -5,7 +5,7 @@ import { ApiProperty } from '@nestjs/swagger';
 import * as enums from '../../enums';
 <% } %>
 
-export class <%= it.name %>Create {
+export class <%= it.entityName %>Create {
 <% it.columns.forEach((field) => { %>
     @ApiProperty()
   <%if (field.dataType.includes("Enum")) {%>
@@ -20,7 +20,7 @@ export class <%= it.name %>Create {
 <% }) %>
 };
 
-export class <%= it.name %> {
+export class <%= it.entityName %> {
 <% if (it.addDefaultPKProperty) { %>
     @ApiProperty()
     id: number;

package/dist/lib/templates/rest/module-rest.eta

@@ -12,5 +12,5 @@ import {<%= it.ctrlName %>} from "./<%= it.entityName %>.controller";
   exports: [<%= it.svcName %>],
   controllers: [<%= it.ctrlName %>],
 })
-export class <%= it.modName %> {}
+export class <%= it.moduleName %> {}
   

package/dist/lib/utils/casing.d.ts

@@ -1,2 +1,3 @@
-export declare const camelCase: (str: string, firstUpper?: boolean) => string;
+export declare function camelCase(str: string): string;
 export declare const snakeCase: (str: string) => string;
+export declare function pascalCase(str: string): string;

package/dist/lib/utils/casing.js

@@ -1,16 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.snakeCase = exports.camelCase = void 0;
-const camelCase = (str, firstUpper) => {
-    const firstLetter = firstUpper ? str[0].toUpperCase() : str[0].toLowerCase();
-    const restOfLetters = str
-        .slice(1)
-        .replace(/_[A-Za-z]/g, (underLetter) => underLetter[1].toUpperCase());
-    return `${firstLetter}${restOfLetters}`;
-};
+exports.pascalCase = exports.snakeCase = exports.camelCase = void 0;
+function camelCase(str) {
+    return str
+        // Insert a space before all caps that are followed by lower case (for PascalCase)
+        .replace(/([\da-z])([A-Z])/g, '$1 $2')
+        // Replace all separators with spaces
+        .replace(/[ _-]+/g, ' ')
+        // Lowercase the string, then uppercase the first letter of each word (except the first)
+        .toLowerCase()
+        .replace(/ (\w)/g, (_, c) => c ? c.toUpperCase() : '')
+        // Remove spaces
+        .replace(/ /g, '');
+}
 exports.camelCase = camelCase;
 const snakeCase = (str) => str[0].toLowerCase() +
     str
         .slice(1, str.length)
         .replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 exports.snakeCase = snakeCase;
+function pascalCase(str) {
+    const c = camelCase(str);
+    return c.charAt(0).toUpperCase() + c.slice(1);
+}
+exports.pascalCase = pascalCase;

package/dist/lib/utils/field.d.ts

@@ -1,5 +1,5 @@
 import { FieldType, Field, ComputedField, Entity } from "../types";
-export declare const getJsTypeFromFieldType: (type: FieldType) => string;
+export declare const getJsTypeFromFieldType: (type: FieldType | string) => string;
 export declare const getDefaultValueForField: (field: Field) => string | null;
 export declare const getFieldForTemplate: (fields: Field[], entityName: string) => ComputedField[];
 export declare const fieldToEnumType: (fieldName: string, entityName: string) => string;

package/dist/lib/utils/field.js

@@ -2,22 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.typeExistsInEntity = exports.fieldToEnumType = exports.getFieldForTemplate = exports.getDefaultValueForField = exports.getJsTypeFromFieldType = void 0;
 const casing_1 = require("./casing");
-const getJsTypeFromFieldType = (type) => {
-    switch (type) {
-        case "array":
-            return "string[]";
-        case "boolean":
-            return "boolean";
-        case "integer":
-            return "number";
-        case "float":
-            return "number";
-        case "text":
-        case "enum":
-        default:
-            return "string";
-    }
+const typeToJsType = {
+    array: "string[]",
+    boolean: "boolean",
+    integer: "number",
+    float: "number",
+    real: "number",
+    double: "number",
+    decimal: "number",
+    numeric: "number",
+    smallint: "number",
+    serial: "number",
+    bigserial: "number",
+    smallserial: "number",
+    bigint: "string",
+    text: "string",
+    varchar: "string",
+    char: "string",
+    uuid: "string",
+    xml: "string",
+    inet: "string",
+    interval: "string",
+    money: "string",
+    date: "string",
+    timestamp: "string",
+    timestamptz: "string",
+    timetz: "string",
+    tsvector: "string",
+    string: "string",
+    json: "any",
+    jsonb: "any",
+    "json-plain": "any",
+    bytea: "Buffer",
+    point: "{ x: number, y: number }",
+    int4range: "{ lower: number, upper: number, lowerInclusive: boolean, upperInclusive: boolean }",
+    enum: "string", // handled elsewhere for custom enums
 };
+const getJsTypeFromFieldType = (type) => { var _a; return (_a = typeToJsType[type]) !== null && _a !== void 0 ? _a : "string"; };
 exports.getJsTypeFromFieldType = getJsTypeFromFieldType;
 const getDefaultValueForField = (field) => {
     var _a, _b;
@@ -57,7 +78,7 @@ const getFieldForTemplate = (fields, entityName) => fields.map((field) => ({
         : (0, exports.getJsTypeFromFieldType)(field.type),
 }));
 exports.getFieldForTemplate = getFieldForTemplate;
-const fieldToEnumType = (fieldName, entityName) => `${(0, casing_1.camelCase)(entityName, true)}${(0, casing_1.camelCase)(fieldName, true)}Enum`;
+const fieldToEnumType = (fieldName, entityName) => `${(0, casing_1.pascalCase)(entityName)}${(0, casing_1.pascalCase)(fieldName)}Enum`;
 exports.fieldToEnumType = fieldToEnumType;
 const typeExistsInEntity = (entity, type) => (entity === null || entity === void 0 ? void 0 : entity.fields)
     ? entity === null || entity === void 0 ? void 0 : entity.fields.findIndex((field) => field.type === type)

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

@@ -13,23 +13,8 @@ const casing_1 = require("../../utils/casing");
  */
 const parseOneToMany = (relationship) => {
     return {
-        [relationship.from]: [
-            {
-                name: relationship.to,
-                type: "OneToMany",
-                biDirectional: true
-            },
-        ],
-        [relationship.to]: [
-            {
-                name: relationship.from,
-                type: "ManyToOne",
-                nullable: relationship.nullable || false,
-                biDirectional: true,
-                index: relationship.index || false,
-                cascadeDelete: relationship.cascadeDelete || false
-            },
-        ],
+        [relationship.from]: [{ name: relationship.to, type: "OneToMany", biDirectional: true, referenceName: relationship.to_name || relationship.to, inverseReferenceName: relationship.from }],
+        [relationship.to]: [{ name: relationship.from, type: "ManyToOne", nullable: relationship.nullable || false, biDirectional: true, index: relationship.index || false, cascadeDelete: relationship.cascadeDelete || false, referenceName: relationship.from, inverseReferenceName: relationship.to_name || relationship.to }],
     };
 };
 exports.parseOneToMany = parseOneToMany;
@@ -95,7 +80,7 @@ const parseManyToMany = (relationship, allRelationships) => {
         isOwningSide = true;
     }
     // Default currentPropertyName if to_name is not provided
-    const currentPropertyName = relationship.to_name || (0, pluralize_1.default)((0, casing_1.camelCase)(relationship.to));
+    const currentPropertyName = relationship.to_name || (0, casing_1.camelCase)((0, pluralize_1.default)(relationship.to));
     let inversePropertyName = inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name;
     // For self-referencing pairs, store the other to_name as inverseReferenceName
     if (isSelfReferencing && selfRefInverse) {
@@ -111,8 +96,8 @@ const parseManyToMany = (relationship, allRelationships) => {
         // Default inverse property name if missing (using calculateInversePropertyName logic later)
     }
     // Calculate reference names, applying defaults if needed
-    const fromSideRefName = relationship.to_name || (relationship.to.toLowerCase() + 's');
-    const toSideRefName = (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name) || (relationship.from.toLowerCase() + 's');
+    const fromSideRefName = relationship.to_name || relationship.to;
+    const toSideRefName = (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name) || relationship.from;
     let joinTableName = relationship.joinTableName;
     // For self-referencing, ensure both sides get join=true and the same custom names
     if (isSelfReferencing && relationship.bi_directional) {
@@ -179,9 +164,9 @@ const createFromOneToOneRelationship = (relationship, inverseDefinition) => {
         type: "OneToOne",
         join: isOwner,
         nullable: relationship.nullable || false,
-        referenceName: relationship.to_name || relationship.to.toLowerCase(),
+        referenceName: relationship.to_name || relationship.to,
         biDirectional: relationship.bi_directional || false,
-        inverseReferenceName: (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name) || relationship.from.toLowerCase(),
+        inverseReferenceName: (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name) || relationship.from,
     };
 };
 /**
@@ -199,8 +184,8 @@ isOwner // Is the 'from' side the owner?
         type: "OneToOne",
         biDirectional: true,
         join: !isOwner,
-        referenceName: inverseDefinition.to_name || relationship.from.toLowerCase(),
-        inverseReferenceName: relationship.to_name || relationship.to.toLowerCase(),
+        referenceName: inverseDefinition.to_name || relationship.from,
+        inverseReferenceName: relationship.to_name || relationship.to,
     };
 };
 /**
@@ -217,8 +202,8 @@ const parseRelationship = (relationship, allRelationships) => {
     }
     switch (relationship.type) {
         case "OneToMany": {
-            const fromSideRefName = relationship.to_name || (relationship.to.toLowerCase() + 's');
-            const toSideRefName = relationship.from.toLowerCase(); // Default singular name for the inverse side
+            const fromSideRefName = relationship.to_name || relationship.to;
+            const toSideRefName = relationship.from;
             return {
                 [relationship.from]: [{ name: relationship.to, type: "OneToMany", biDirectional: true, referenceName: fromSideRefName, inverseReferenceName: toSideRefName }],
                 [relationship.to]: [{ name: relationship.from, type: "ManyToOne", nullable: relationship.nullable || false, biDirectional: true, index: relationship.index || false, cascadeDelete: relationship.cascadeDelete || false, referenceName: toSideRefName, inverseReferenceName: fromSideRefName }],
@@ -226,7 +211,7 @@ const parseRelationship = (relationship, allRelationships) => {
         }
         case "ManyToOne":
             return {
-                [relationship.from]: [{ name: relationship.to, type: "ManyToOne", referenceName: relationship.to_name || relationship.to.toLowerCase(), nullable: relationship.nullable || false, index: relationship.index || false }],
+                [relationship.from]: [{ name: relationship.to, type: "ManyToOne", referenceName: relationship.to_name || relationship.to, nullable: relationship.nullable || false, index: relationship.index || false }],
             };
         case "OneToOne": {
             const inverseOnetoOneDef = allRelationships.find((def) => def.from === relationship.to &&
@@ -257,7 +242,7 @@ const parseRelationship = (relationship, allRelationships) => {
                         type: "OneToOne",
                         biDirectional: true,
                         join: !(fromRel.join || false),
-                        referenceName: relationship.from.toLowerCase(),
+                        referenceName: relationship.from,
                         inverseReferenceName: fromRel.referenceName || undefined // Reference the 'from' side's name, default to undefined if null
                     };
                     responseMap[relationship.to] = [
@@ -352,10 +337,8 @@ const getRelationshipForTemplate = (entityName, relationships) => {
     if (!relationships) {
         return [];
     }
-    // More comprehensive deduplication to handle all duplicate cases
-    const dedupedRelationships = [];
-    const processedRefs = new Map();
     // First pass: Group by name and referenceName (more specific)
+    const processedRefs = new Map();
     relationships.forEach((relationship) => {
         var _a;
         const name = relationship.name;
@@ -366,27 +349,15 @@ const getRelationshipForTemplate = (entityName, relationships) => {
             processedRefs.set(key, relationship);
         }
     });
-    // Second pass: Use name-only as a fallback for edge cases
-    // This helps with ManyToMany cases where both sides exist with different join flags
-    const nameOnlyKeys = new Set();
-    processedRefs.forEach((rel) => {
-        if (!nameOnlyKeys.has(rel.name)) {
-            nameOnlyKeys.add(rel.name);
-            dedupedRelationships.push(rel);
-        }
-        else if (rel.join === true) {
-            // If we already have this name but the current one is the owner (join=true), 
-            // replace the existing one
-            const existingIdx = dedupedRelationships.findIndex(r => r.name === rel.name);
-            if (existingIdx !== -1 && !dedupedRelationships[existingIdx].join) {
-                dedupedRelationships[existingIdx] = rel;
-            }
-        }
-    });
-    return dedupedRelationships.map((relationship) => {
+    // Only deduplicate by name+referenceName, not just name
+    return [...processedRefs.values()].map((relationship) => {
         const thisReferenceName = relationship.referenceName;
         const relationshipName = (0, casing_1.camelCase)(thisReferenceName || relationship.name);
         const needsPluralInverse = relationship.type === 'ManyToOne' || relationship.type === 'ManyToMany';
+        // DEBUG LOGGING
+        if (process.env.DEBUG) {
+            console.log('[DEBUG] relationship.name:', relationship.name, '| relationship.referenceName:', relationship.referenceName, '| thisReferenceName:', thisReferenceName, '| pluralizedRelationshipName:', (0, casing_1.camelCase)((0, pluralize_1.default)(thisReferenceName || relationship.name)), '| pluralizedName:', (0, casing_1.camelCase)((0, pluralize_1.default)(relationship.name)));
+        }
         const inverseSidePropertyName = calculateInversePropertyName(relationship, entityName, relationshipName, needsPluralInverse);
         if (relationship.biDirectional && !relationship.inverseReferenceName &&
             (relationship.type === 'ManyToMany' || relationship.type === 'OneToMany' || relationship.type === 'OneToOne')) {
@@ -395,8 +366,8 @@ const getRelationshipForTemplate = (entityName, relationships) => {
         return {
             ...relationship,
             relationshipName,
-            pluralizedRelationshipName: (0, pluralize_1.default)(relationshipName),
-            pluralizedName: (0, pluralize_1.default)((0, casing_1.camelCase)(relationship.name)),
+            pluralizedRelationshipName: (0, casing_1.camelCase)((0, pluralize_1.default)(thisReferenceName || relationship.name)),
+            pluralizedName: (0, casing_1.camelCase)((0, pluralize_1.default)(relationship.name)),
             camelCasedName: (0, casing_1.camelCase)(relationship.name),
             camelCasedId: (0, exports.getRelationshipIdField)(relationship),
             entityName: (0, casing_1.camelCase)(entityName),
@@ -422,15 +393,22 @@ const getNestedRelationships = (entityName, relationshipMap, prefix = "", visite
         const referenceName = getRelationshipName(relationship);
         const formattedName = type === "ManyToOne" || type === "OneToOne"
             ? (0, casing_1.camelCase)(referenceName)
-            : (0, pluralize_1.default)((0, casing_1.camelCase)(referenceName));
-        const relationshipPath = prefix
-            ? `${prefix}.${formattedName}`
-            : formattedName;
+            : (0, casing_1.camelCase)((0, pluralize_1.default)(referenceName));
+        // Create the relationship path while preserving camelCase
+        let relationshipPath;
+        if (prefix) {
+            // Split the path by dots and preserve each segment's casing
+            const segments = prefix.split('.');
+            relationshipPath = `${segments.join('.')}.${formattedName}`;
+        }
+        else {
+            relationshipPath = formattedName;
+        }
         const hasChild = relationshipPath.includes(".");
         const exists = prefix
             .split(".")
             .some((a) => a === (0, casing_1.camelCase)(referenceName) ||
-            a === (0, pluralize_1.default)((0, casing_1.camelCase)(referenceName)));
+            a === (0, casing_1.camelCase)((0, pluralize_1.default)(referenceName)));
         const deepEnough = prefix.split(".").length >= 4;
         const canAdd = hasChild && !exists && !deepEnough;
         if (canAdd) {

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

@@ -26,26 +26,26 @@ const parse_1 = require("./parse");
                     {
                         name: 'EntityB',
                         type: 'ManyToMany',
-                        referenceName: 'entitybs',
+                        referenceName: 'EntityB',
                         join: true,
                         biDirectional: true,
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'entityas', // Simplified default
+                        inverseReferenceName: 'EntityA', // PascalCase entity name
                     },
                 ],
                 EntityB: [
                     {
                         name: 'EntityA',
                         type: 'ManyToMany',
-                        referenceName: 'entityas',
+                        referenceName: 'EntityA',
                         join: false,
                         biDirectional: true,
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'entitybs', // Simplified default
+                        inverseReferenceName: 'EntityB', // PascalCase entity name
                     },
                 ],
             };
@@ -75,20 +75,20 @@ const parse_1 = require("./parse");
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'users', // Simplified default
+                        inverseReferenceName: 'User', // PascalCase entity name
                     },
                 ],
                 Group: [
                     {
                         name: 'User',
                         type: 'ManyToMany',
-                        referenceName: 'users',
+                        referenceName: 'User',
                         join: false,
                         biDirectional: true,
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'userGroups', // Expect preserved camelCase
+                        inverseReferenceName: 'userGroups', // Preserved camelCase from to_name
                     },
                 ],
             };
@@ -109,7 +109,7 @@ const parse_1 = require("./parse");
                     {
                         name: 'Tag',
                         type: 'ManyToMany',
-                        referenceName: 'tags',
+                        referenceName: 'Tag',
                         join: true,
                         biDirectional: false,
                         joinTableName: undefined,
@@ -144,26 +144,26 @@ const parse_1 = require("./parse");
                     {
                         name: 'Course',
                         type: 'ManyToMany',
-                        referenceName: 'courses',
+                        referenceName: 'Course',
                         join: true,
                         biDirectional: true,
                         joinTableName: 'enrollments',
                         joinColumnName: 'student_id',
                         inverseJoinColumnName: 'course_id',
-                        inverseReferenceName: 'students', // Simplified default
+                        inverseReferenceName: 'Student', // PascalCase entity name
                     },
                 ],
                 Course: [
                     {
                         name: 'Student',
                         type: 'ManyToMany',
-                        referenceName: 'students',
+                        referenceName: 'Student',
                         join: false,
                         biDirectional: true,
                         joinTableName: undefined,
                         joinColumnName: undefined,
                         inverseJoinColumnName: undefined,
-                        inverseReferenceName: 'courses', // Simplified default
+                        inverseReferenceName: 'Course', // PascalCase entity name
                     },
                 ],
             };
@@ -202,17 +202,28 @@ const parse_1 = require("./parse");
             // Check User relationships
             (0, globals_1.expect)(result.User).toHaveLength(3);
             (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({ name: 'Profile', type: 'OneToOne', referenceName: 'userProfile', biDirectional: true, join: false })); // Expect preserved camelCase
-            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({ name: 'Post', type: 'OneToMany', referenceName: 'posts', biDirectional: true })); // Simplified default
-            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({ name: 'Role', type: 'ManyToMany', referenceName: 'roles', biDirectional: true, join: false })); // Simplified default
+            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({ name: 'Post', type: 'OneToMany', referenceName: 'Post', biDirectional: true })); // PascalCase entity name
+            (0, globals_1.expect)(result.User).toContainEqual(globals_1.expect.objectContaining({ name: 'Role', type: 'ManyToMany', referenceName: 'Role', biDirectional: true, join: false })); // PascalCase entity name
             // Check Profile relationship
             (0, globals_1.expect)(result.Profile).toHaveLength(1);
-            (0, globals_1.expect)(result.Profile).toContainEqual(globals_1.expect.objectContaining({ name: 'User', type: 'OneToOne', referenceName: 'user', biDirectional: true, join: true })); // Simplified default singular
+            (0, globals_1.expect)(result.Profile).toContainEqual(globals_1.expect.objectContaining({
+                name: 'User',
+                type: 'OneToOne',
+                referenceName: 'User',
+                biDirectional: true,
+                join: true
+            }));
             // Check Post relationship
             (0, globals_1.expect)(result.Post).toHaveLength(1);
-            (0, globals_1.expect)(result.Post).toContainEqual(globals_1.expect.objectContaining({ name: 'User', type: 'ManyToOne', referenceName: 'user', biDirectional: true })); // Simplified default singular
+            (0, globals_1.expect)(result.Post).toContainEqual(globals_1.expect.objectContaining({
+                name: 'User',
+                type: 'ManyToOne',
+                referenceName: 'User',
+                biDirectional: true
+            }));
             // Check Role relationship
             (0, globals_1.expect)(result.Role).toHaveLength(1);
-            (0, globals_1.expect)(result.Role).toContainEqual(globals_1.expect.objectContaining({ name: 'User', type: 'ManyToMany', referenceName: 'users', biDirectional: true, join: true })); // Simplified default
+            (0, globals_1.expect)(result.Role).toContainEqual(globals_1.expect.objectContaining({ name: 'User', type: 'ManyToMany', referenceName: 'User', biDirectional: true, join: true })); // PascalCase entity name
         });
     });
 });

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

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

package/dist/test-nested-relationships.js

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

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

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

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

@@ -60,10 +60,11 @@ const parse_1 = require("../../lib/utils/relationships/parse");
         // Run the function
         const result = (0, parse_1.getRelationshipForTemplate)(entityName, mockRelationships);
         // Assertions
-        // Current behavior: Only one relationship is kept during name-based deduplication (second phase)
-        (0, globals_1.expect)(result.length).toBe(1);
-        // The first one is kept in the Set processing 
-        (0, globals_1.expect)(result[0].relationshipName).toBe("workspaces");
+        // New behavior: Both relationships with different referenceName should be kept
+        (0, globals_1.expect)(result.length).toBe(2);
+        const referenceNames = result.map(r => r.relationshipName || r.referenceName);
+        (0, globals_1.expect)(referenceNames).toContain("workspaces");
+        (0, globals_1.expect)(referenceNames).toContain("ownedWorkspaces");
     });
     (0, globals_1.test)("should prioritize owner side (join=true) when deduplicating", () => {
         // Scenario based on real issue: two ManyToMany relationships to same entity

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.4",
+  "version": "0.1.6",
   "commands": {
     "server:new": {
       "id": "server:new",

package/package.json

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