@apso/cli 0.0.45 → 0.1.4

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

@@ -1,9 +1,16 @@
 "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]: [
@@ -26,6 +33,13 @@ const parseOneToMany = (relationship) => {
     };
 };
 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,75 +54,240 @@ const parseManytoOne = (relationship) => {
     };
 };
 exports.parseManytoOne = parseManytoOne;
-const parseManyToMany = (relationship) => {
+/**
+ * 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');
+    // 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;
+    if (isSelfReferencing && relationship.bi_directional) {
+        // Find the other relationship that completes the pair
+        selfRefInverse = allRelationships.find(def => def.from === relationship.from &&
+            def.to === relationship.to &&
+            def.type === 'ManyToMany' &&
+            def.bi_directional &&
+            def.to_name !== 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, pluralize_1.default)((0, casing_1.camelCase)(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) {
+        inversePropertyName = selfRefInverse.to_name;
+    }
+    if (!currentPropertyName) {
+        console.warn(`[APSO WARNING] Missing 'to_name' for ManyToMany: ${relationship.from} -> ${relationship.to}. Skipping this definition.`);
+        return {};
+    }
+    // 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.toLowerCase() + 's');
+    const toSideRefName = (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name) || (relationship.from.toLowerCase() + 's');
+    let joinTableName = relationship.joinTableName;
+    // 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;
+        }
+    }
+    const fromSideRelationship = {
+        name: relationship.to,
+        type: "ManyToMany",
+        referenceName: fromSideRefName,
+        join: isOwningSide,
+        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]: [
-            {
-                name: relationship.to,
-                type: "ManyToMany",
-                referenceName: relationship.to_name || null,
-                join: true,
-                biDirectional: relationship.bi_directional || false,
-            },
-        ],
+        [relationship.from]: [fromSideRelationship],
     };
-    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: "ManyToMany",
-                biDirectional: true,
-            },
+            ...(response[relationship.to] || []),
+            toSideRelationship
         ];
     }
     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,
-            },
-        ],
+/**
+ * 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.toLowerCase(),
+        biDirectional: relationship.bi_directional || false,
+        inverseReferenceName: (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name) || relationship.from.toLowerCase(),
     };
-    if (relationship.bi_directional) {
-        response[relationship.to] = [
-            {
-                name: relationship.from,
-                type: "OneToOne",
-                biDirectional: true,
-            },
-        ];
-    }
-    return response;
 };
-exports.parseOneToOne = parseOneToOne;
-const parseRelationship = (relationship) => {
+/**
+ * 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.toLowerCase(),
+        inverseReferenceName: relationship.to_name || relationship.to.toLowerCase(),
+    };
+};
+/**
+ * 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":
-            return (0, exports.parseOneToMany)(relationship);
+        case "OneToMany": {
+            const fromSideRefName = relationship.to_name || (relationship.to.toLowerCase() + 's');
+            const toSideRefName = relationship.from.toLowerCase(); // Default singular name for the inverse side
+            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 }],
+            };
+        }
         case "ManyToOne":
-            return (0, exports.parseManytoOne)(relationship);
-        case "ManyToMany":
-            return (0, exports.parseManyToMany)(relationship);
-        case "OneToOne":
-            return (0, exports.parseOneToOne)(relationship);
+            return {
+                [relationship.from]: [{ name: relationship.to, type: "ManyToOne", referenceName: relationship.to_name || relationship.to.toLowerCase(), 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");
+            // 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.toLowerCase(),
+                        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) {
-        const parsedResult = (0, exports.parseRelationship)(rel);
+        const parsedResult = (0, exports.parseRelationship)(rel, relationships);
         for (const key of Object.keys(parsedResult)) {
-            response[key] = [...(response[key] || []), ...parsedResult[key]];
+            if (parsedResult[key] && parsedResult[key].length > 0) {
+                response[key] = [...(response[key] || []), ...parsedResult[key]];
+            }
         }
     }
     return response;
@@ -124,12 +303,95 @@ 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') {
+        if (relationship.inverseReferenceName) {
+            return (0, casing_1.camelCase)(relationship.inverseReferenceName);
+        }
+        const fallback = (0, casing_1.camelCase)(entityName);
+        return needsPluralInverse ? (0, pluralize_1.default)(fallback) : fallback;
+    }
+    if (relationship.inverseReferenceName) {
+        let inverse = (0, casing_1.camelCase)(relationship.inverseReferenceName);
+        if (needsPluralInverse) {
+            inverse = (0, pluralize_1.default)(inverse);
+        }
+        // Check for special plural terms
+        const specialPlurals = [
+            'children', 'people', 'men', 'women', 'mice', 'geese', 'teeth', 'feet',
+            'oxen', 'cacti', 'indices', 'vertices', 'analyses', 'crises', 'diagnoses',
+            'media', 'criteria', 'data', 'parents'
+        ];
+        if (specialPlurals.includes(relationship.inverseReferenceName)) {
+            return relationship.inverseReferenceName;
+        }
+        return inverse;
+    }
+    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) => {
-        const relationshipName = getRelationshipName(relationship);
+    // More comprehensive deduplication to handle all duplicate cases
+    const dedupedRelationships = [];
+    const processedRefs = new Map();
+    // First pass: Group by name and referenceName (more specific)
+    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);
+        }
+    });
+    // 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) => {
+        const thisReferenceName = relationship.referenceName;
+        const relationshipName = (0, casing_1.camelCase)(thisReferenceName || relationship.name);
+        const needsPluralInverse = relationship.type === 'ManyToOne' || relationship.type === 'ManyToMany';
+        const inverseSidePropertyName = calculateInversePropertyName(relationship, entityName, relationshipName, needsPluralInverse);
+        if (relationship.biDirectional && !relationship.inverseReferenceName &&
+            (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.`);
+        }
         return {
             ...relationship,
             relationshipName,
@@ -140,7 +402,8 @@ const getRelationshipForTemplate = (entityName, relationships) => {
             entityName: (0, casing_1.camelCase)(entityName),
             joinTable: relationship.join || false,
             biDirectional: relationship.biDirectional || false,
-            cascadeDelete: relationship.cascadeDelete || false,
+            referenceName: thisReferenceName || undefined,
+            inverseSidePropertyName,
         };
     });
 };

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

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

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

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const parse_1 = require("./parse");
+(0, globals_1.describe)('parseRelationships', () => {
+    // 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)('ManyToMany Relationships', () => {
+        (0, globals_1.it)('should parse a single bidirectional ManyToMany definition', () => {
+            const relationships = [
+                {
+                    from: 'EntityA',
+                    to: 'EntityB',
+                    type: 'ManyToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true,
+                },
+            ];
+            const expected = {
+                EntityA: [
+                    {
+                        name: 'EntityB',
+                        type: 'ManyToMany',
+                        referenceName: 'entitybs',
+                        join: true,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'entityas', // Simplified default
+                    },
+                ],
+                EntityB: [
+                    {
+                        name: 'EntityA',
+                        type: 'ManyToMany',
+                        referenceName: 'entityas',
+                        join: false,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'entitybs', // Simplified default
+                    },
+                ],
+            };
+            const result = (0, parse_1.parseRelationships)(relationships);
+            (0, globals_1.expect)(result).toEqual(expected);
+        });
+        (0, globals_1.it)('should parse a single bidirectional ManyToMany with to_name', () => {
+            const relationships = [
+                {
+                    from: 'User',
+                    to: 'Group',
+                    type: 'ManyToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true,
+                    // eslint-disable-next-line camelcase
+                    to_name: 'userGroups',
+                },
+            ];
+            const expected = {
+                User: [
+                    {
+                        name: 'Group',
+                        type: 'ManyToMany',
+                        referenceName: 'userGroups',
+                        join: true,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'users', // Simplified default
+                    },
+                ],
+                Group: [
+                    {
+                        name: 'User',
+                        type: 'ManyToMany',
+                        referenceName: 'users',
+                        join: false,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'userGroups', // Expect preserved camelCase
+                    },
+                ],
+            };
+            const result = (0, parse_1.parseRelationships)(relationships);
+            (0, globals_1.expect)(result).toEqual(expected);
+        });
+        (0, globals_1.it)('should parse a unidirectional ManyToMany definition', () => {
+            const relationships = [
+                {
+                    from: 'Post',
+                    to: 'Tag',
+                    type: 'ManyToMany',
+                    // bi_directional is false or omitted
+                },
+            ];
+            const expected = {
+                Post: [
+                    {
+                        name: 'Tag',
+                        type: 'ManyToMany',
+                        referenceName: 'tags',
+                        join: true,
+                        biDirectional: false,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: undefined, // Correct: No inverse name for unidirectional
+                    },
+                ],
+                // No entry expected for Tag
+            };
+            const result = (0, parse_1.parseRelationships)(relationships);
+            (0, globals_1.expect)(result).toEqual(expected);
+        });
+        (0, globals_1.it)('should handle join table details correctly', () => {
+            const relationships = [
+                {
+                    from: 'Student',
+                    to: 'Course',
+                    type: 'ManyToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true,
+                    // UNUSED: eslint-disable-next-line camelcase
+                    joinTableName: 'enrollments',
+                    // UNUSED: eslint-disable-next-line camelcase
+                    joinColumnName: 'student_id',
+                    // UNUSED: eslint-disable-next-line camelcase
+                    inverseJoinColumnName: 'course_id',
+                },
+            ];
+            const expected = {
+                Student: [
+                    {
+                        name: 'Course',
+                        type: 'ManyToMany',
+                        referenceName: 'courses',
+                        join: true,
+                        biDirectional: true,
+                        joinTableName: 'enrollments',
+                        joinColumnName: 'student_id',
+                        inverseJoinColumnName: 'course_id',
+                        inverseReferenceName: 'students', // Simplified default
+                    },
+                ],
+                Course: [
+                    {
+                        name: 'Student',
+                        type: 'ManyToMany',
+                        referenceName: 'students',
+                        join: false,
+                        biDirectional: true,
+                        joinTableName: undefined,
+                        joinColumnName: undefined,
+                        inverseJoinColumnName: undefined,
+                        inverseReferenceName: 'courses', // Simplified default
+                    },
+                ],
+            };
+            const result = (0, parse_1.parseRelationships)(relationships);
+            (0, globals_1.expect)(result).toEqual(expected);
+        });
+    });
+    (0, globals_1.describe)('Mixed Relationship Types', () => {
+        (0, globals_1.it)('should correctly parse ManyToMany alongside other types', () => {
+            const relationships = [
+                {
+                    from: 'User',
+                    to: 'Profile',
+                    type: 'OneToOne',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true,
+                    // eslint-disable-next-line camelcase
+                    to_name: 'userProfile'
+                },
+                {
+                    from: 'User',
+                    to: 'Post',
+                    type: 'OneToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true // Implies ManyToOne on Post
+                },
+                {
+                    from: 'Role',
+                    to: 'User',
+                    type: 'ManyToMany',
+                    // eslint-disable-next-line camelcase
+                    bi_directional: true
+                }
+            ];
+            const result = (0, parse_1.parseRelationships)(relationships);
+            // 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
+            // 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
+            // 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
+            // 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
+        });
+    });
+});

package/dist/tests/utils/relationship-deduplication.spec.d.ts

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