@apso/cli 0.0.45 → 0.1.4

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/templates/rest/service-rest-spec.eta

@@ -0,0 +1,38 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { <%= it.svcName %> } from './<%= it.entityName %>.service';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { <%= it.entityName %> } from './<%= it.entityName %>.entity';
+
+describe('<%= it.svcName %>', () => {
+  let service: <%= it.svcName %>;
+  let mockRepository: any;
+
+  beforeEach(async () => {
+    mockRepository = {
+      find: jest.fn().mockResolvedValue([]),
+      findOne: jest.fn().mockResolvedValue({}),
+      save: jest.fn().mockResolvedValue({}),
+      create: jest.fn().mockReturnValue({}),
+      update: jest.fn().mockResolvedValue({}),
+      delete: jest.fn().mockResolvedValue({}),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        <%= it.svcName %>,
+        {
+          provide: getRepositoryToken(<%= it.entityName %>),
+          useValue: mockRepository,
+        },
+      ],
+    }).compile();
+
+    service = module.get<<%= it.svcName %>>(<%= it.svcName %>);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  // Add more tests as needed
+}); 

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,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;
-export declare const parseManyToMany: (relationship: ApsorcRelationship) => RelationshipMap;
-export declare const parseOneToOne: (relationship: ApsorcRelationship) => RelationshipMap;
-export declare const parseRelationship: (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;
+/**
+ * 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[];