@apso/cli 0.0.45 → 0.1.0

package/README.md

@@ -47,6 +47,8 @@ Then navigate to the newly created service and update the apsorc file according
 
 Sample of apsorc files for both v1 and v2 are given in apso-cli code at "test/apsorc-json" so you can check it out in order to make sure that your apsorc file follows the right pattern.
 
+For detailed examples of configuring complex relationships, especially ManyToMany and self-referencing patterns, see the [Relationship Configuration Use Cases](./UseCases.md).
+
 You can also provide the key "apiType" in the apsorc file e.g (Rest, Graphql) incase you want to generate the GraphQL backend by default it would be REST.
 
 Install the npm modules before continuing further.

package/dist/lib/templates/entities/entity.eta

@@ -74,42 +74,57 @@ export class <%= it.name %> {
 
 // Associations    
 <% it.associations.forEach((assoc) => { %>
+
+    <%// Generate property ONLY based on referenceName (to_name) %>
+    <%// relationshipName is the camelCased version of referenceName %>
+    <%// pluralizedRelationshipName is the pluralized version (for arrays) %>
+
     <% if (assoc.type === 'OneToMany') { %>
 
         @OneToMany(
             () => <%= assoc.name %>,
-            <%= assoc.camelCasedName %> => <%= assoc.camelCasedName %>.<%= assoc.entityName %>
+            <%= assoc.camelCasedName %> => <%= assoc.camelCasedName %>.<%= assoc.inverseSidePropertyName %>
         )
-        <%= assoc.pluralizedName %>: <%= assoc.name %>[]
-    
+        <%= assoc.pluralizedRelationshipName %>: <%= assoc.name %>[];
+
     <% } else if (assoc.type === 'ManyToOne') { %>
         <% if (assoc.index) { %>
         @Index()
         <% } %>
-        @ManyToOne(() => <%= assoc.name %><% if (assoc.biDirectional) { %>, <%= assoc.camelCasedName %> => <%= assoc.camelCasedName %>.<%= it.pluralizedName %><% } %><% if (assoc.cascadeDelete) { %>, { onDelete: "CASCADE" }<% } %>)
+        @ManyToOne(() => <%= assoc.name %><% if (assoc.biDirectional) { %>, <%= assoc.camelCasedName %> => <%= assoc.camelCasedName %>.<%= assoc.inverseSidePropertyName %><% } %><% if (assoc.cascadeDelete) { %>, { onDelete: "CASCADE" }<% } %>)
         @JoinColumn({ name: '<%= assoc.camelCasedId %>' })
-        <%= assoc.relationshipName %>: <%= assoc.name %>
+        <%= assoc.relationshipName %>: <%= assoc.name %>;
 
         @Column({ type: "integer", <% if (assoc.nullable) { %> nullable: true <% } %>})
         <%= assoc.camelCasedId %>: number;
-    
+
     <% } else if (assoc.type === 'ManyToMany') { %>
-    
-        @ManyToMany(() => <%= assoc.name %><% if (assoc.biDirectional) { %>, <%= assoc.camelCasedName %> => <%= assoc.camelCasedName %>.<%= it.pluralizedName %><% } %>)
-        <% if (assoc.joinTable) { %>@JoinTable()<% } %>
-        <%= assoc.pluralizedRelationshipName %>: <%= assoc.name %>[]
-    
+
+        @ManyToMany(() => <%= assoc.name %><% if (assoc.biDirectional) { %>, <%= assoc.camelCasedName %> => <%= assoc.camelCasedName %>.<%= assoc.inverseSidePropertyName %><% } %>)
+        <% if (assoc.joinTable) { %>
+        @JoinTable(<%
+          let joinTableArgs = [];
+          if (assoc.joinTableName) { joinTableArgs.push(`name: '${assoc.joinTableName}'`); }
+          if (assoc.joinColumnName) { joinTableArgs.push(`joinColumn: { name: '${assoc.joinColumnName}', referencedColumnName: 'id' }`); }
+          if (assoc.inverseJoinColumnName) { joinTableArgs.push(`inverseJoinColumn: { name: '${assoc.inverseJoinColumnName}', referencedColumnName: 'id' }`); }
+          if (joinTableArgs.length > 0) { 
+        %>{
+          <%~ joinTableArgs.join(',\n          ') %>
+        }<% } %>)
+        <% } %>
+        <%= assoc.pluralizedRelationshipName %>: <%= assoc.name %>[];
+
     <% } else if (assoc.type === 'OneToOne') { %>
-    
+
         @OneToOne(
             (type: any) => <%= assoc.name%>,
-            <% if (assoc.biDirectional) { %>(p) => p.<%= assoc.entityName %>,<% } %>
+             <% if (assoc.biDirectional) { %>(<%= assoc.camelCasedName %>) => <%= assoc.camelCasedName %>.<%= assoc.inverseSidePropertyName %>,<% } %>
             {
                 onDelete: "CASCADE",
                 cascade: ["insert", "update"],
             })
-        @JoinColumn()
-        <%= assoc.relationshipName %>: <%= assoc.name %>
+         <% if (assoc.joinTable) { %>@JoinColumn()<% } %>
+        <%= assoc.relationshipName %>: <%= assoc.name %>;
 
     <% } %>
 <% }) %>

package/dist/lib/templates/rest/controller-rest.eta

@@ -25,6 +25,7 @@ import {<%= it.svcName %>} from './<%= it.entityName %>.service';
         <% if (it.associations.length) { %>
             join: {
                 <% it.associations.forEach((assoc) => { %>
+                    <% /* Removed check: relying on distinct pluralizedRelationshipName */ %>
                     <% if (assoc.type === 'OneToMany') { %>
                     <%= assoc.pluralizedRelationshipName %>: { eager: false },
                     <% } else if (assoc.type === 'ManyToOne') { %>

package/dist/lib/types/relationship.d.ts

@@ -8,6 +8,9 @@ export interface ApsorcRelationship {
     bi_directional?: boolean;
     cascadeDelete?: boolean;
     index?: boolean;
+    joinTableName?: string;
+    joinColumnName?: string;
+    inverseJoinColumnName?: string;
 }
 export interface Relationship {
     name: string;
@@ -18,6 +21,10 @@ export interface Relationship {
     biDirectional?: boolean;
     cascadeDelete?: boolean;
     index?: boolean;
+    joinTableName?: string;
+    joinColumnName?: string;
+    inverseJoinColumnName?: string;
+    inverseReferenceName?: string;
 }
 export interface RelationshipForTemplate extends Relationship {
     relationshipName: string;
@@ -28,6 +35,7 @@ export interface RelationshipForTemplate extends Relationship {
     entityName: string;
     joinTable: boolean;
     biDirectional: boolean;
+    inversePropertyName?: string;
 }
 export type RelationshipMap = {
     [key: string]: Relationship[];

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

@@ -63,17 +63,23 @@ const convertAssociationToRelationship = (entityName, association, entities) =>
 };
 const parseV1Relationships = (entities) => {
     const relationshipMap = {};
+    // First, convert all v1 associations to the v2 ApsorcRelationship format
+    const apsorcRelationships = [];
     for (const entity of entities) {
-        if (!entity.associations) {
-            continue;
-        }
-        for (const association of entity.associations) {
-            const apsorcRelationship = convertAssociationToRelationship(entity.name, association, entities);
-            if (apsorcRelationship === null) {
-                continue;
+        if (entity.associations) {
+            for (const association of entity.associations) {
+                const convertedRel = convertAssociationToRelationship(entity.name, association, entities);
+                if (convertedRel) {
+                    apsorcRelationships.push(convertedRel);
+                }
             }
-            const parsedResult = (0, parse_1.parseRelationship)(apsorcRelationship);
-            for (const key of Object.keys(parsedResult)) {
+        }
+    }
+    // Now, process each converted relationship, passing the full list
+    for (const apsorcRelationship of apsorcRelationships) {
+        const parsedResult = (0, parse_1.parseRelationship)(apsorcRelationship, apsorcRelationships);
+        for (const key of Object.keys(parsedResult)) {
+            if (parsedResult[key] && parsedResult[key].length > 0) { // Ensure non-empty result
                 relationshipMap[key] = [
                     ...(relationshipMap[key] || []),
                     ...parsedResult[key],

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

@@ -1,9 +1,9 @@
 import { ApsorcRelationship, Relationship, RelationshipMap, RelationshipForTemplate } from "../../types";
 export declare const parseOneToMany: (relationship: ApsorcRelationship) => RelationshipMap;
 export declare const parseManytoOne: (relationship: ApsorcRelationship) => RelationshipMap;
-export declare const parseManyToMany: (relationship: ApsorcRelationship) => RelationshipMap;
+export declare const parseManyToMany: (relationship: ApsorcRelationship, allRelationships: ApsorcRelationship[]) => RelationshipMap;
 export declare const parseOneToOne: (relationship: ApsorcRelationship) => RelationshipMap;
-export declare const parseRelationship: (relationship: ApsorcRelationship) => RelationshipMap;
+export declare const parseRelationship: (relationship: ApsorcRelationship, allRelationships: ApsorcRelationship[]) => RelationshipMap;
 export declare const parseRelationships: (relationships: ApsorcRelationship[]) => RelationshipMap;
 export declare const getRelationshipIdField: (relationship: Relationship) => string;
 export declare const getRelationshipForTemplate: (entityName: string, relationships: Relationship[]) => RelationshipForTemplate[];

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

@@ -40,27 +40,64 @@ const parseManytoOne = (relationship) => {
     };
 };
 exports.parseManytoOne = parseManytoOne;
-const parseManyToMany = (relationship) => {
+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);
+    // 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 = Boolean(relationship.joinTableName || relationship.joinColumnName || relationship.inverseJoinColumnName);
+    const currentPropertyName = relationship.to_name;
+    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 {};
+    }
+    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.`);
+    }
+    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,
+        join: isOwningSide,
+        biDirectional: relationship.bi_directional || false,
+        joinTableName: joinTableName,
+        joinColumnName: joinColumnName,
+        inverseJoinColumnName: inverseJoinColumnName,
+        inverseReferenceName: inversePropertyName || undefined,
+    };
     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) {
-        response[relationship.to] = [
-            {
-                name: relationship.from,
-                type: "ManyToMany",
-                biDirectional: true,
-            },
-        ];
-    }
     return response;
 };
 exports.parseManyToMany = parseManyToMany;
@@ -89,16 +126,33 @@ const parseOneToOne = (relationship) => {
     return response;
 };
 exports.parseOneToOne = parseOneToOne;
-const parseRelationship = (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);
+            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 }],
+            };
         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 || null, 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 }
+                ];
+            }
+            return responseMap;
+        }
     }
     return {};
 };
@@ -106,9 +160,11 @@ exports.parseRelationship = parseRelationship;
 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 +180,47 @@ const getRelationshipIdField = (relationship) => {
     return `${getRelationshipName(relationship)}Id`;
 };
 exports.getRelationshipIdField = getRelationshipIdField;
+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;
+};
 const getRelationshipForTemplate = (entityName, relationships) => {
     if (!relationships) {
         return [];
     }
     return relationships.map((relationship) => {
-        const relationshipName = getRelationshipName(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}.`);
+        }
         return {
             ...relationship,
             relationshipName,
@@ -140,7 +231,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/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.45",
+  "version": "0.1.0",
   "commands": {
     "server:new": {
       "id": "server:new",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apso/cli",
-  "version": "0.0.45",
+  "version": "0.1.0",
   "description": "Apso CLI",
   "author": "Apso by Mavric - @mavric",
   "bin": {