@apso/cli 0.34.0 → 0.35.0

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

@@ -10,10 +10,15 @@ import { ApsorcRelationship, Relationship, RelationshipMap, RelationshipForTempl
 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.
+ * Bidirectional by default, mirroring parseOneToMany with from/to swapped:
+ * the target entity gets the inverse OneToMany collection (and with it the
+ * controller join allowlist), so `Authors?join=books` works no matter which
+ * direction the .apsorc declared the relationship in.
+ * Set `bi_directional: false` to keep the old FK-only unidirectional shape.
+ * Self-referencing relationships stay unidirectional (both sides would
+ * collide on the same RelationshipMap key).
  * @param relationship The .apsorc relationship definition.
- * @returns A RelationshipMap containing only the entry for the 'from' side.
+ * @returns A RelationshipMap with entries for both sides (or just 'from' when unidirectional).
  */
 export declare const parseManytoOne: (relationship: ApsorcRelationship) => RelationshipMap;
 /**

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

@@ -39,20 +39,52 @@ 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.
+ * Bidirectional by default, mirroring parseOneToMany with from/to swapped:
+ * the target entity gets the inverse OneToMany collection (and with it the
+ * controller join allowlist), so `Authors?join=books` works no matter which
+ * direction the .apsorc declared the relationship in.
+ * Set `bi_directional: false` to keep the old FK-only unidirectional shape.
+ * Self-referencing relationships stay unidirectional (both sides would
+ * collide on the same RelationshipMap key).
  * @param relationship The .apsorc relationship definition.
- * @returns A RelationshipMap containing only the entry for the 'from' side.
+ * @returns A RelationshipMap with entries for both sides (or just 'from' when unidirectional).
  */
 const parseManytoOne = (relationship) => {
+    const unidirectional = relationship.bi_directional === false ||
+        relationship.from === relationship.to;
+    if (unidirectional) {
+        return {
+            [relationship.from]: [
+                {
+                    name: relationship.to,
+                    type: "ManyToOne",
+                    referenceName: relationship.to_name || null,
+                    nullable: relationship.nullable || false,
+                    index: relationship.index || false,
+                },
+            ],
+        };
+    }
     return {
         [relationship.from]: [
             {
                 name: relationship.to,
                 type: "ManyToOne",
-                referenceName: relationship.to_name || null,
                 nullable: relationship.nullable || false,
+                biDirectional: true,
                 index: relationship.index || false,
+                cascadeDelete: relationship.cascadeDelete || false,
+                referenceName: relationship.to_name || relationship.to,
+                inverseReferenceName: relationship.from,
+            },
+        ],
+        [relationship.to]: [
+            {
+                name: relationship.from,
+                type: "OneToMany",
+                biDirectional: true,
+                referenceName: relationship.from,
+                inverseReferenceName: relationship.to_name || relationship.to,
             },
         ],
     };
@@ -264,18 +296,52 @@ const parseRelationship = (relationship, allRelationships) => {
                 ],
             };
         }
-        case "ManyToOne":
+        case "ManyToOne": {
+            // Bidirectional by default, mirroring the OneToMany case with the roles
+            // swapped: the target entity gets the inverse OneToMany collection (and
+            // with it the controller join allowlist), so the collection-side embed
+            // works no matter which direction .apsorc declared the relationship in.
+            // `bi_directional: false` keeps the old FK-only shape; self-references
+            // stay unidirectional (both sides would collide on the same map key).
+            const manySideRefName = relationship.to_name || relationship.to;
+            if (relationship.bi_directional === false ||
+                relationship.from === relationship.to) {
+                return {
+                    [relationship.from]: [
+                        {
+                            name: relationship.to,
+                            type: "ManyToOne",
+                            referenceName: manySideRefName,
+                            nullable: relationship.nullable || false,
+                            index: relationship.index || false,
+                        },
+                    ],
+                };
+            }
             return {
                 [relationship.from]: [
                     {
                         name: relationship.to,
                         type: "ManyToOne",
-                        referenceName: relationship.to_name || relationship.to,
                         nullable: relationship.nullable || false,
+                        biDirectional: true,
                         index: relationship.index || false,
+                        cascadeDelete: relationship.cascadeDelete || false,
+                        referenceName: manySideRefName,
+                        inverseReferenceName: relationship.from,
+                    },
+                ],
+                [relationship.to]: [
+                    {
+                        name: relationship.from,
+                        type: "OneToMany",
+                        biDirectional: true,
+                        referenceName: relationship.from,
+                        inverseReferenceName: manySideRefName,
                     },
                 ],
             };
+        }
         case "OneToOne": {
             const inverseOnetoOneDef = allRelationships.find((def) => def.from === relationship.to &&
                 def.to === relationship.from &&

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@apso/cli",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@apso/cli",
-      "version": "0.34.0",
+      "version": "0.35.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@biomejs/biome": "^1.9.4",

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.34.0",
+  "version": "0.35.0",
   "commands": {
     "config": {
       "id": "config",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "mcpName": "io.github.apsoai/apso",
   "description": "Apso CLI",
   "author": "Apso by Mavric - @mavric",