@apso/cli 0.5.0 → 0.7.0

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

@@ -13,8 +13,27 @@ const casing_1 = require("../casing");
  */
 const parseOneToMany = (relationship) => {
     return {
-        [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 }],
+        [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;
@@ -51,9 +70,9 @@ exports.parseManytoOne = parseManytoOne;
  */
 const parseManyToMany = (relationship, allRelationships) => {
     // Find the inverse relationship definition (if exists)
-    const inverseDefinition = allRelationships.find(def => def.from === relationship.to &&
+    const inverseDefinition = allRelationships.find((def) => def.from === relationship.to &&
         def.to === relationship.from &&
-        def.type === 'ManyToMany');
+        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
@@ -61,19 +80,22 @@ const parseManyToMany = (relationship, allRelationships) => {
     let selfRefInverse = null;
     if (isSelfReferencing && relationship.bi_directional) {
         // Find the other relationship that completes the pair
-        selfRefInverse = allRelationships.find(def => def.from === relationship.from &&
+        selfRefInverse = allRelationships.find((def) => def.from === relationship.from &&
             def.to === relationship.to &&
-            def.type === 'ManyToMany' &&
+            def.type === "ManyToMany" &&
             def.bi_directional &&
             def.to_name !== relationship.to_name);
     }
-    let isOwningSide = relationship.joinTableName || relationship.joinColumnName || relationship.inverseJoinColumnName
+    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);
+        isOwningSide = !(inverseDefinition.joinTableName ||
+            inverseDefinition.joinColumnName ||
+            inverseDefinition.inverseJoinColumnName);
     }
     if (isOwningSide === undefined) {
         // If neither has details, default to the current definition being the owner
@@ -113,10 +135,18 @@ const parseManyToMany = (relationship, allRelationships) => {
         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
+        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],
@@ -135,14 +165,20 @@ const parseManyToMany = (relationship, allRelationships) => {
             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,
+            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] = [
             ...(response[relationship.to] || []),
-            toSideRelationship
+            toSideRelationship,
         ];
     }
     return response;
@@ -205,13 +241,40 @@ const parseRelationship = (relationship, allRelationships) => {
             const fromSideRefName = relationship.to_name || relationship.to;
             const toSideRefName = relationship.from;
             return {
-                [relationship.from]: [{ name: relationship.to, type: "OneToMany", biDirectional: true, referenceName: fromSideRefName, inverseReferenceName: toSideRefName }],
-                [relationship.to]: [{ name: relationship.from, type: "ManyToOne", nullable: relationship.nullable || false, biDirectional: true, index: relationship.index || false, cascadeDelete: relationship.cascadeDelete || false, referenceName: toSideRefName, inverseReferenceName: fromSideRefName }],
+                [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 || relationship.to, 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 &&
@@ -243,7 +306,7 @@ const parseRelationship = (relationship, allRelationships) => {
                         biDirectional: true,
                         join: !(fromRel.join || false),
                         referenceName: relationship.from,
-                        inverseReferenceName: fromRel.referenceName || undefined // Reference the 'from' side's name, default to undefined if null
+                        inverseReferenceName: fromRel.referenceName || undefined, // Reference the 'from' side's name, default to undefined if null
                     };
                     responseMap[relationship.to] = [
                         ...(responseMap[relationship.to] || []),
@@ -300,7 +363,7 @@ exports.getRelationshipIdField = getRelationshipIdField;
  */
 const calculateInversePropertyName = (relationship, entityName, relationshipName, needsPluralInverse) => {
     const isSelfReferencing = relationship.name === entityName;
-    if (isSelfReferencing && relationship.type === 'ManyToMany') {
+    if (isSelfReferencing && relationship.type === "ManyToMany") {
         if (relationship.inverseReferenceName) {
             return (0, casing_1.camelCase)(relationship.inverseReferenceName);
         }
@@ -314,9 +377,25 @@ const calculateInversePropertyName = (relationship, entityName, relationshipName
         }
         // 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'
+            "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;
@@ -341,7 +420,7 @@ const getRelationshipForTemplate = (entityName, relationships, entities) => {
     // Create entity map for looking up primary key types
     const entityMap = new Map();
     if (entities) {
-        entities.forEach(entity => {
+        entities.forEach((entity) => {
             entityMap.set(entity.name, entity);
         });
     }
@@ -353,7 +432,8 @@ const getRelationshipForTemplate = (entityName, relationships, entities) => {
         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))) {
+        if (!processedRefs.has(key) ||
+            (relationship.join && !((_a = processedRefs.get(key)) === null || _a === void 0 ? void 0 : _a.join))) {
             processedRefs.set(key, relationship);
         }
     });
@@ -361,7 +441,7 @@ const getRelationshipForTemplate = (entityName, relationships, entities) => {
     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';
+        const needsPluralInverse = relationship.type === "ManyToOne" || relationship.type === "ManyToMany";
         // DEBUG LOGGING
         // if (process.env.DEBUG) {
         //   console.log(
@@ -373,13 +453,16 @@ const getRelationshipForTemplate = (entityName, relationships, entities) => {
         //   );
         // }
         const inverseSidePropertyName = calculateInversePropertyName(relationship, entityName, relationshipName, needsPluralInverse);
-        if (relationship.biDirectional && !relationship.inverseReferenceName &&
-            (relationship.type === 'ManyToMany' || relationship.type === 'OneToMany' || relationship.type === 'OneToOne')) {
+        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.`);
         }
         // Look up the referenced entity's primary key type
         const referencedEntity = entityMap.get(relationship.name);
-        const referencedEntityPrimaryKeyType = (referencedEntity === null || referencedEntity === void 0 ? void 0 : referencedEntity.primaryKeyType) || 'serial'; // Default to 'serial' if not specified
+        const referencedEntityPrimaryKeyType = (referencedEntity === null || referencedEntity === void 0 ? void 0 : referencedEntity.primaryKeyType) || "serial"; // Default to 'serial' if not specified
         return {
             ...relationship,
             relationshipName,
@@ -477,7 +560,9 @@ function* generateNestedRelationships(entityName, relationshipMap, maxDepth = 4,
 exports.generateNestedRelationships = generateNestedRelationships;
 // In-memory collector
 function getNestedRelationships(entityName, relationshipMap, maxDepth) {
-    return [...generateNestedRelationships(entityName, relationshipMap, maxDepth)];
+    return [
+        ...generateNestedRelationships(entityName, relationshipMap, maxDepth),
+    ];
 }
 exports.getNestedRelationships = getNestedRelationships;
 // Streaming function