@apso/cli 0.1.0 → 0.1.4

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,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,12 +54,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 +82,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, 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) {
@@ -68,95 +105,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.toLowerCase() + 's');
+    const toSideRefName = (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name) || (relationship.from.toLowerCase() + 's');
     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.toLowerCase(),
+        biDirectional: relationship.bi_directional || false,
+        inverseReferenceName: (inverseDefinition === null || inverseDefinition === void 0 ? void 0 : inverseDefinition.to_name) || relationship.from.toLowerCase(),
+    };
+};
+/**
+ * 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":
+        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: 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.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' && 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.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) {
@@ -180,6 +303,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,18 +341,56 @@ 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) => {
+    // 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.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,

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

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