@apso/cli 0.1.0 → 0.1.5

package/dist/lib/templates/rest/service-rest-spec.eta

@@ -0,0 +1,38 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { <%= it.svcName %> } from './<%= it.entityName %>.service';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { <%= it.entityName %> } from './<%= it.entityName %>.entity';
+
+describe('<%= it.svcName %>', () => {
+  let service: <%= it.svcName %>;
+  let mockRepository: any;
+
+  beforeEach(async () => {
+    mockRepository = {
+      find: jest.fn().mockResolvedValue([]),
+      findOne: jest.fn().mockResolvedValue({}),
+      save: jest.fn().mockResolvedValue({}),
+      create: jest.fn().mockReturnValue({}),
+      update: jest.fn().mockResolvedValue({}),
+      delete: jest.fn().mockResolvedValue({}),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        <%= it.svcName %>,
+        {
+          provide: getRepositoryToken(<%= it.entityName %>),
+          useValue: mockRepository,
+        },
+      ],
+    }).compile();
+
+    service = module.get<<%= it.svcName %>>(<%= it.svcName %>);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  // Add more tests as needed
+}); 

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.js

@@ -57,7 +57,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.d.ts

@@ -1,11 +1,55 @@
 import { ApsorcRelationship, Relationship, RelationshipMap, RelationshipForTemplate } from "../../types";
+/**
+ * Parses a OneToMany relationship definition.
+ * These are treated as bidirectional from the .apsorc definition.
+ * Only generates the configuration for the 'from' side.
+ * @param relationship The .apsorc relationship definition.
+ * @returns A RelationshipMap containing only the entry for the 'from' side.
+ */
 export declare const parseOneToMany: (relationship: ApsorcRelationship) => RelationshipMap;
+/**
+ * Parses a ManyToOne relationship definition.
+ * These are treated as unidirectional from the .apsorc definition.
+ * Only generates the configuration for the 'from' side.
+ * @param relationship The .apsorc relationship definition.
+ * @returns A RelationshipMap containing only the entry for the 'from' side.
+ */
 export declare const parseManytoOne: (relationship: ApsorcRelationship) => RelationshipMap;
+/**
+ * Parses a ManyToMany relationship definition.
+ * Determines bidirectionality based on flags and inverse definitions.
+ * Determines the owning side (which gets the @JoinTable decorator).
+ * Calculates reference names (property names), defaulting if 'to_name' is missing.
+ * If bidirectional, generates configuration for both 'from' and 'to' sides.
+ * @param relationship The .apsorc relationship definition.
+ * @param allRelationships The full list of relationship definitions for finding inverses.
+ * @returns A RelationshipMap containing entries for one or both sides.
+ */
 export declare const parseManyToMany: (relationship: ApsorcRelationship, allRelationships: ApsorcRelationship[]) => RelationshipMap;
-export declare const parseOneToOne: (relationship: ApsorcRelationship) => RelationshipMap;
+/**
+ * Parses a single relationship definition from .apsorc.
+ * Dispatches to the appropriate type-specific parser (parseManyToMany, parseOneToMany, etc.).
+ * For bidirectional relationships, the type-specific parsers handle generating data for both sides.
+ * @param relationship The single .apsorc relationship definition to parse.
+ * @param allRelationships The full list of relationship definitions (needed for context, e.g., finding inverses).
+ * @returns A RelationshipMap, potentially containing entries for both entities involved in the relationship.
+ */
 export declare const parseRelationship: (relationship: ApsorcRelationship, allRelationships: ApsorcRelationship[]) => RelationshipMap;
+/**
+ * Parses the entire array of relationship definitions from the .apsorc file.
+ * Iterates through each definition, calls parseRelationship, and merges the results.
+ * @param relationships The array of relationship definitions from .apsorc.
+ * @returns A comprehensive RelationshipMap mapping entity names to their Relationship objects.
+ */
 export declare const parseRelationships: (relationships: ApsorcRelationship[]) => RelationshipMap;
 export declare const getRelationshipIdField: (relationship: Relationship) => string;
+/**
+ * Transforms the parsed Relationship data into the final format needed by the entity/controller templates.
+ * 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.
+ * @returns An array of RelationshipForTemplate objects with extra properties for the template.
+ */
 export declare const getRelationshipForTemplate: (entityName: string, relationships: Relationship[]) => RelationshipForTemplate[];
 export declare const getNestedRelationships: (entityName: string, relationshipMap: RelationshipMap, prefix?: string, visited?: Set<string>) => string[];
 export declare const getRelationshipsForImport: (entityName: string, relationships?: Relationship[]) => string[];

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

@@ -1,31 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRelationshipsForImport = exports.getNestedRelationships = exports.getRelationshipForTemplate = exports.getRelationshipIdField = exports.parseRelationships = exports.parseRelationship = exports.parseOneToOne = exports.parseManyToMany = exports.parseManytoOne = exports.parseOneToMany = void 0;
+exports.getRelationshipsForImport = exports.getNestedRelationships = exports.getRelationshipForTemplate = exports.getRelationshipIdField = exports.parseRelationships = exports.parseRelationship = exports.parseManyToMany = exports.parseManytoOne = exports.parseOneToMany = void 0;
 const tslib_1 = require("tslib");
 const pluralize_1 = tslib_1.__importDefault(require("pluralize"));
 const casing_1 = require("../../utils/casing");
+/**
+ * Parses a OneToMany relationship definition.
+ * These are treated as bidirectional from the .apsorc definition.
+ * Only generates the configuration for the 'from' side.
+ * @param relationship The .apsorc relationship definition.
+ * @returns A RelationshipMap containing only the entry for the 'from' side.
+ */
 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;
+/**
+ * Parses a ManyToOne relationship definition.
+ * These are treated as unidirectional from the .apsorc definition.
+ * Only generates the configuration for the 'from' side.
+ * @param relationship The .apsorc relationship definition.
+ * @returns A RelationshipMap containing only the entry for the 'from' side.
+ */
 const parseManytoOne = (relationship) => {
     return {
         [relationship.from]: [
@@ -40,12 +39,23 @@ const parseManytoOne = (relationship) => {
     };
 };
 exports.parseManytoOne = parseManytoOne;
+/**
+ * Parses a ManyToMany relationship definition.
+ * Determines bidirectionality based on flags and inverse definitions.
+ * Determines the owning side (which gets the @JoinTable decorator).
+ * Calculates reference names (property names), defaulting if 'to_name' is missing.
+ * If bidirectional, generates configuration for both 'from' and 'to' sides.
+ * @param relationship The .apsorc relationship definition.
+ * @param allRelationships The full list of relationship definitions for finding inverses.
+ * @returns A RelationshipMap containing entries for one or both sides.
+ */
 const parseManyToMany = (relationship, allRelationships) => {
     // Find the inverse relationship definition (if exists)
     const inverseDefinition = allRelationships.find(def => def.from === relationship.to &&
         def.to === relationship.from &&
-        def.type === 'ManyToMany' &&
-        def.bi_directional);
+        def.type === 'ManyToMany');
+    // Determine if the relationship should be treated as bidirectional
+    const isEffectivelyBiDirectional = Boolean(relationship.bi_directional || (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.bi_directional));
     // For self-referencing relationships, find the matching inverse by to_name
     const isSelfReferencing = relationship.from === relationship.to;
     let selfRefInverse = null;
@@ -57,8 +67,20 @@ const parseManyToMany = (relationship, allRelationships) => {
             def.bi_directional &&
             def.to_name !== relationship.to_name);
     }
-    let isOwningSide = Boolean(relationship.joinTableName || relationship.joinColumnName || relationship.inverseJoinColumnName);
-    const currentPropertyName = relationship.to_name;
+    let isOwningSide = relationship.joinTableName || relationship.joinColumnName || relationship.inverseJoinColumnName
+        ? true
+        : undefined;
+    if (isOwningSide === undefined && inverseDefinition) {
+        // If current doesn't have details, check if inverse does
+        isOwningSide =
+            !(inverseDefinition.joinTableName || inverseDefinition.joinColumnName || inverseDefinition.inverseJoinColumnName);
+    }
+    if (isOwningSide === undefined) {
+        // If neither has details, default to the current definition being the owner
+        isOwningSide = true;
+    }
+    // Default currentPropertyName if to_name is not provided
+    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) {
@@ -68,95 +90,181 @@ const parseManyToMany = (relationship, allRelationships) => {
         console.warn(`[APSO WARNING] Missing 'to_name' for ManyToMany: ${relationship.from} -> ${relationship.to}. Skipping this definition.`);
         return {};
     }
-    if (relationship.bi_directional && !inversePropertyName) {
-        console.warn(`[APSO WARNING] Missing inverse 'to_name' for bidirectional ManyToMany: ${relationship.to} -> ${relationship.from}. Inverse mapping might be incorrect.`);
+    // Check for missing inverse 'to_name' only if it's effectively bidirectional
+    if (isEffectivelyBiDirectional && !inversePropertyName) {
+        console.info(`[APSO INFO] No 'to_name' provided for bidirectional ManyToMany: ${relationship.to} -> ${relationship.from}. Using default inverse property name. Add 'to_name' for explicit control.`);
+        // Default inverse property name if missing (using calculateInversePropertyName logic later)
     }
+    // Calculate reference names, applying defaults if needed
+    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;
-    let joinColumnName = relationship.joinColumnName;
-    let inverseJoinColumnName = relationship.inverseJoinColumnName;
     // For self-referencing, ensure both sides get join=true and the same custom names
     if (isSelfReferencing && relationship.bi_directional) {
         isOwningSide = true; // Both sides get @JoinTable for self-ref
         // If current def doesn't have names, but inverse does, grab them
         if (!joinTableName && (selfRefInverse === null || selfRefInverse === void 0 ? void 0 : selfRefInverse.joinTableName)) {
             joinTableName = selfRefInverse.joinTableName;
-            joinColumnName = selfRefInverse.joinColumnName;
-            inverseJoinColumnName = selfRefInverse.inverseJoinColumnName;
         }
     }
     const fromSideRelationship = {
         name: relationship.to,
         type: "ManyToMany",
-        referenceName: currentPropertyName,
+        referenceName: fromSideRefName,
         join: isOwningSide,
-        biDirectional: relationship.bi_directional || false,
-        joinTableName: joinTableName,
-        joinColumnName: joinColumnName,
-        inverseJoinColumnName: inverseJoinColumnName,
-        inverseReferenceName: inversePropertyName || undefined,
+        biDirectional: isEffectivelyBiDirectional,
+        joinTableName: isOwningSide ? (relationship.joinTableName || undefined) : undefined,
+        joinColumnName: isOwningSide ? (relationship.joinColumnName || undefined) : undefined,
+        inverseJoinColumnName: isOwningSide ? (relationship.inverseJoinColumnName || undefined) : undefined,
+        inverseReferenceName: isEffectivelyBiDirectional ? toSideRefName : undefined, // Only add inverse name if bidirectional
     };
     const response = {
         [relationship.from]: [fromSideRelationship],
     };
-    return response;
-};
-exports.parseManyToMany = parseManyToMany;
-const parseOneToOne = (relationship) => {
-    const response = {
-        [relationship.from]: [
-            {
-                name: relationship.to,
-                type: "OneToOne",
-                join: true,
-                nullable: relationship.nullable || false,
-                referenceName: relationship.to_name || null,
-                biDirectional: relationship.bi_directional || false,
-            },
-        ],
-    };
-    if (relationship.bi_directional) {
+    // If bidirectional, add the inverse relationship definition to the map
+    if (isEffectivelyBiDirectional) {
+        // Calculate the property name for the inverse side
+        // If inversePropertyName (from inverse to_name) exists, use it, else default based on 'from' entity
+        // const inverseSideReferenceName = inversePropertyName || pluralize(camelCase(relationship.from)); << Old way
+        // Determine if the inverse side is the owning side
+        const isInverseOwningSide = !isOwningSide;
+        const toSideRelationship = {
+            name: relationship.from,
+            type: "ManyToMany",
+            referenceName: toSideRefName,
+            join: isInverseOwningSide,
+            biDirectional: true,
+            // Add join details ONLY if the inverse side IS the owner
+            joinTableName: isInverseOwningSide ? ((inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.joinTableName) || undefined) : undefined,
+            joinColumnName: isInverseOwningSide ? ((inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.joinColumnName) || undefined) : undefined,
+            inverseJoinColumnName: isInverseOwningSide ? ((inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.inverseJoinColumnName) || undefined) : undefined,
+            inverseReferenceName: fromSideRefName, // The reference name of the other side
+        };
         response[relationship.to] = [
-            {
-                name: relationship.from,
-                type: "OneToOne",
-                biDirectional: true,
-            },
+            ...(response[relationship.to] || []),
+            toSideRelationship
         ];
     }
     return response;
 };
-exports.parseOneToOne = parseOneToOne;
+exports.parseManyToMany = parseManyToMany;
+/**
+ * Helper function to create the Relationship object for the 'from' side of a OneToOne definition.
+ * Determines the owning side (@JoinColumn).
+ * @param relationship The .apsorc relationship definition.
+ * @param inverseDefinition The found inverse definition, if any.
+ * @returns The Relationship object for the 'from' side.
+ */
+const createFromOneToOneRelationship = (relationship, inverseDefinition) => {
+    // Determine owner side: if bidirectional, the side *without* to_name is owner.
+    // If not bidirectional, the 'from' side is always the owner.
+    const isOwner = relationship.bi_directional ? !relationship.to_name : true;
+    return {
+        name: relationship.to,
+        type: "OneToOne",
+        join: isOwner,
+        nullable: relationship.nullable || false,
+        referenceName: relationship.to_name || relationship.to,
+        biDirectional: relationship.bi_directional || false,
+        inverseReferenceName: (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name) || relationship.from,
+    };
+};
+/**
+ * Helper function to create the Relationship object for the 'to' side of a bidirectional OneToOne definition.
+ * @param relationship The original .apsorc relationship definition.
+ * @param inverseDefinition The inverse definition (assumed to exist).
+ * @param isOwner Indicates if the 'from' side was determined to be the owner.
+ * @returns The Relationship object for the 'to' side.
+ */
+const createToOneToOneRelationship = (relationship, inverseDefinition, // Assumed to exist if this is called
+isOwner // Is the 'from' side the owner?
+) => {
+    return {
+        name: relationship.from,
+        type: "OneToOne",
+        biDirectional: true,
+        join: !isOwner,
+        referenceName: inverseDefinition.to_name || relationship.from,
+        inverseReferenceName: relationship.to_name || relationship.to,
+    };
+};
+/**
+ * Parses a single relationship definition from .apsorc.
+ * Dispatches to the appropriate type-specific parser (parseManyToMany, parseOneToMany, etc.).
+ * For bidirectional relationships, the type-specific parsers handle generating data for both sides.
+ * @param relationship The single .apsorc relationship definition to parse.
+ * @param allRelationships The full list of relationship definitions (needed for context, e.g., finding inverses).
+ * @returns A RelationshipMap, potentially containing entries for both entities involved in the relationship.
+ */
 const parseRelationship = (relationship, allRelationships) => {
     if (relationship.type === "ManyToMany") {
         return (0, exports.parseManyToMany)(relationship, allRelationships);
     }
     switch (relationship.type) {
-        case "OneToMany":
+        case "OneToMany": {
+            const fromSideRefName = relationship.to_name || relationship.to;
+            const toSideRefName = relationship.from;
             return {
-                [relationship.from]: [{ name: relationship.to, type: "OneToMany", biDirectional: true, referenceName: relationship.to_name || null }],
-                [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: 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 }],
             };
+        }
         case "ManyToOne":
             return {
-                [relationship.from]: [{ name: relationship.to, type: "ManyToOne", referenceName: relationship.to_name || null, 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 && def.to === relationship.from && def.type === 'OneToOne' && def.bi_directional);
-            const isOneToOneOwner = relationship.bi_directional ? !relationship.to_name : true;
-            const fromOneToOne = { name: relationship.to, type: "OneToOne", join: isOneToOneOwner, nullable: relationship.nullable || false, referenceName: relationship.to_name || undefined, biDirectional: relationship.bi_directional || false, inverseReferenceName: (inverseOnetoOneDef === null || inverseOnetoOneDef === void 0 ? void 0 : inverseOnetoOneDef.to_name) || undefined };
-            const responseMap = { [relationship.from]: [fromOneToOne] };
-            if (relationship.bi_directional && inverseOnetoOneDef) {
-                responseMap[relationship.to] = [
-                    ...(responseMap[relationship.to] || []),
-                    { name: relationship.from, type: "OneToOne", biDirectional: true, join: !isOneToOneOwner, referenceName: inverseOnetoOneDef.to_name || undefined, inverseReferenceName: relationship.to_name || undefined }
-                ];
+            const inverseOnetoOneDef = allRelationships.find((def) => def.from === relationship.to &&
+                def.to === relationship.from &&
+                def.type === "OneToOne");
+            // Determine bidirectionality based on current flag or inverse flag
+            const isEffectivelyBiDirectional = Boolean(relationship.bi_directional || (inverseOnetoOneDef === null || inverseOnetoOneDef === void 0 ? void 0 : inverseOnetoOneDef.bi_directional));
+            // Create the relationship for the 'from' side
+            const fromRel = createFromOneToOneRelationship(relationship, inverseOnetoOneDef);
+            const responseMap = { [relationship.from]: [fromRel] };
+            // If it's effectively bidirectional, create and add the relationship for the 'to' side
+            if (isEffectivelyBiDirectional) {
+                // Need the inverse definition to exist to correctly create the inverse side
+                if (inverseOnetoOneDef) {
+                    const isFromSideOwner = fromRel.join || false; // Determine owner from the created 'from' side
+                    const toRel = createToOneToOneRelationship(relationship, inverseOnetoOneDef, isFromSideOwner);
+                    responseMap[relationship.to] = [
+                        ...(responseMap[relationship.to] || []),
+                        toRel,
+                    ];
+                }
+                else {
+                    // Handle the edge case where one side declares bidirectional but the inverse definition is missing
+                    // We still need to add *something* for the inverse side, likely without join/owner info
+                    console.warn(`[APSO WARNING] Bidirectional OneToOne defined for ${relationship.from} -> ${relationship.to}, but inverse definition ${relationship.to} -> ${relationship.from} is missing. Inverse side generation may be incomplete.`);
+                    const fallbackToRel = {
+                        name: relationship.from,
+                        type: "OneToOne",
+                        biDirectional: true,
+                        join: !(fromRel.join || false),
+                        referenceName: relationship.from,
+                        inverseReferenceName: fromRel.referenceName || undefined // Reference the 'from' side's name, default to undefined if null
+                    };
+                    responseMap[relationship.to] = [
+                        ...(responseMap[relationship.to] || []),
+                        fallbackToRel,
+                    ];
+                }
             }
             return responseMap;
         }
     }
+    // Fallback / Error case?
+    console.error(`[APSO ERROR] Unknown relationship type: ${relationship.type}`);
     return {};
 };
 exports.parseRelationship = parseRelationship;
+/**
+ * Parses the entire array of relationship definitions from the .apsorc file.
+ * Iterates through each definition, calls parseRelationship, and merges the results.
+ * @param relationships The array of relationship definitions from .apsorc.
+ * @returns A comprehensive RelationshipMap mapping entity names to their Relationship objects.
+ */
 const parseRelationships = (relationships) => {
     const response = {};
     for (const rel of relationships) {
@@ -180,6 +288,16 @@ const getRelationshipIdField = (relationship) => {
     return `${getRelationshipName(relationship)}Id`;
 };
 exports.getRelationshipIdField = getRelationshipIdField;
+/**
+ * Calculates the final property name on the inverse side of a relationship.
+ * Used by the entity template for the TypeORM decorator's inverse side function.
+ * Handles self-referencing cases and defaults.
+ * @param relationship The Relationship object for the current side.
+ * @param entityName The name of the entity for the current side.
+ * @param relationshipName The camelCased property name for the current side.
+ * @param needsPluralInverse Whether the inverse property name should be plural.
+ * @returns The calculated inverse property name.
+ */
 const calculateInversePropertyName = (relationship, entityName, relationshipName, needsPluralInverse) => {
     const isSelfReferencing = relationship.name === entityName;
     if (isSelfReferencing && relationship.type === 'ManyToMany') {
@@ -208,24 +326,48 @@ const calculateInversePropertyName = (relationship, entityName, relationshipName
     const fallback = (0, casing_1.camelCase)(entityName);
     return needsPluralInverse ? (0, pluralize_1.default)(fallback) : fallback;
 };
+/**
+ * Transforms the parsed Relationship data into the final format needed by the entity/controller templates.
+ * 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.
+ * @returns An array of RelationshipForTemplate objects with extra properties for the template.
+ */
 const getRelationshipForTemplate = (entityName, relationships) => {
     if (!relationships) {
         return [];
     }
-    return relationships.map((relationship) => {
+    // First pass: Group by name and referenceName (more specific)
+    const processedRefs = new Map();
+    relationships.forEach((relationship) => {
+        var _a;
+        const name = relationship.name;
+        const refName = relationship.referenceName || "default";
+        const key = `${name}:${refName}`;
+        // Use the relationship with join=true if there are duplicates (this is the owning side)
+        if (!processedRefs.has(key) || (relationship.join && !((_a = processedRefs.get(key)) === null || _a === void 0 ? void 0 : _a.join))) {
+            processedRefs.set(key, 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')) {
-            console.warn(`[APSO WARNING] Using default inverse property name '${inverseSidePropertyName}' for ${entityName}.${relationshipName}. Define 'to_name' for the inverse relationship ${relationship.name}->${entityName}.`);
+            console.info(`[APSO INFO] Using default property name '${inverseSidePropertyName}' for ${relationship.name}->${entityName}. To customize, add 'to_name' in your relationship definition.`);
         }
         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),
@@ -251,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.d.ts

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