@currentjs/gen 0.2.2 → 0.3.0

package/dist/generators/domainModelGenerator.js

@@ -50,6 +50,7 @@ class DomainModelGenerator {
             array: 'any[]',
             object: 'object'
         };
+        this.availableModels = new Set();
     }
     getDefaultValue(type) {
         switch (type) {
@@ -71,8 +72,27 @@ class DomainModelGenerator {
         }
     }
     mapType(yamlType) {
+        // Check if this is a known model (relationship)
+        if (this.availableModels.has(yamlType)) {
+            return yamlType;
+        }
         return this.typeMapping[yamlType] || 'any';
     }
+    setAvailableModels(models) {
+        this.availableModels.clear();
+        models.forEach(model => {
+            this.availableModels.add(model.name);
+        });
+    }
+    getRelatedModelImports(modelConfig) {
+        const imports = [];
+        modelConfig.fields.forEach(field => {
+            if (this.availableModels.has(field.type) && field.type !== modelConfig.name) {
+                imports.push(`import { ${field.type} } from './${field.type}';`);
+            }
+        });
+        return imports;
+    }
     generateConstructorParameter(field) {
         const tsType = this.mapType(field.type);
         const isOptional = !field.required && !field.auto;
@@ -87,14 +107,34 @@ class DomainModelGenerator {
         }
         return param;
     }
+    isRelationshipField(field) {
+        return this.availableModels.has(field.type);
+    }
+    getForeignKeyFieldName(field) {
+        // Convention: fieldName + 'Id' (e.g., owner -> ownerId)
+        return field.name + 'Id';
+    }
+    generateForeignKeyParameter(field) {
+        const foreignKeyName = this.getForeignKeyFieldName(field);
+        const isOptional = !field.required && !field.auto;
+        let param = `public ${foreignKeyName}`;
+        if (isOptional) {
+            param += '?';
+        }
+        param += ': number';
+        return param;
+    }
     generateSetterMethods(modelConfig) {
         const setterMethods = [];
         modelConfig.fields.forEach(field => {
             if (!field.auto && field.name !== 'id') {
                 const tsType = this.mapType(field.type);
                 const methodName = `set${field.name.charAt(0).toUpperCase() + field.name.slice(1)}`;
+                // For all fields (including relationships), generate simple setter
+                // Domain model doesn't care about FKs - that's infrastructure concern
+                const isOptional = !field.required && !field.auto;
                 const setter = `
-    ${methodName}(${field.name}: ${tsType}): void {
+    ${methodName}(${field.name}: ${tsType}${isOptional ? ' | undefined' : ''}): void {
         this.${field.name} = ${field.name};
     }`;
                 setterMethods.push(setter);
@@ -121,11 +161,16 @@ class DomainModelGenerator {
         const sortedFields = this.sortFieldsByRequired(modelConfig.fields);
         // Process other fields
         sortedFields.forEach(field => {
+            // For relationship fields, only add the relationship object (not FK)
+            // Domain model works with objects only - FK is infrastructure concern
             constructorParams.push(this.generateConstructorParameter(field));
         });
         const constructorParamsStr = constructorParams.join(',\n        ');
         const setterMethods = this.generateSetterMethods(modelConfig);
-        return `export class ${className} {
+        // Generate imports for related models
+        const imports = this.getRelatedModelImports(modelConfig);
+        const importsStr = imports.length > 0 ? imports.join('\n') + '\n\n' : '';
+        return `${importsStr}export class ${className} {
     public constructor(
         ${constructorParamsStr}
     ) { }
@@ -143,6 +188,8 @@ ${setterMethods}
             const app = config;
             Object.values(app.modules).forEach(moduleConfig => {
                 if (moduleConfig.models && moduleConfig.models.length > 0) {
+                    // Set available models for relationship detection
+                    this.setAvailableModels(moduleConfig.models);
                     moduleConfig.models.forEach(m => {
                         result[m.name] = this.generateModel(m);
                     });
@@ -151,6 +198,8 @@ ${setterMethods}
         }
         else if (config.models) {
             const module = config;
+            // Set available models for relationship detection
+            this.setAvailableModels(module.models);
             module.models.forEach(m => {
                 result[m.name] = this.generateModel(m);
             });
@@ -162,6 +211,8 @@ ${setterMethods}
         if (config.modules) {
             Object.values(config.modules).forEach(moduleConfig => {
                 if (moduleConfig.models && moduleConfig.models.length > 0) {
+                    // Set available models for relationship detection
+                    this.setAvailableModels(moduleConfig.models);
                     moduleConfig.models.forEach(m => {
                         result[m.name] = this.generateModel(m);
                     });
@@ -169,7 +220,10 @@ ${setterMethods}
             });
         }
         else if (config.models) {
-            config.models.forEach(m => {
+            const module = config;
+            // Set available models for relationship detection
+            this.setAvailableModels(module.models);
+            module.models.forEach(m => {
                 result[m.name] = this.generateModel(m);
             });
         }

package/dist/generators/serviceGenerator.d.ts

@@ -1,3 +1,11 @@
+interface FieldConfig {
+    name: string;
+    type: string;
+    required?: boolean;
+    unique?: boolean;
+    auto?: boolean;
+    displayFields?: string[];
+}
 interface ActionConfig {
     handlers: string[];
 }
@@ -7,7 +15,7 @@ interface PermissionConfig {
 }
 interface ModelConfig {
     name: string;
-    fields: any[];
+    fields: FieldConfig[];
 }
 type ModuleConfig = {
     models?: ModelConfig[];
@@ -15,6 +23,10 @@ type ModuleConfig = {
     permissions?: PermissionConfig[];
 };
 export declare class ServiceGenerator {
+    private availableModels;
+    private setAvailableModels;
+    private isRelationshipField;
+    private getForeignKeyFieldName;
     private hasPermissions;
     private getActionPermissions;
     private generatePermissionCheck;
@@ -26,12 +38,15 @@ export declare class ServiceGenerator {
     private getMethodCallParams;
     private sortFieldsByRequired;
     private generateConstructorArgs;
+    private generateRelationshipLoading;
     private generateUpdateSetterCalls;
     private replaceTemplateVars;
     private getServiceMethodName;
     private generateHandlerMethod;
     generateServiceForModel(model: ModelConfig, moduleName: string, moduleConfig: ModuleConfig, hasGlobalPermissions: boolean): string;
     generateService(moduleName: string, moduleConfig: ModuleConfig, hasGlobalPermissions: boolean): string;
+    private generateForeignStoreImports;
+    private generateForeignStoreConstructorParams;
     private generateCustomImports;
     generateFromYamlFile(yamlFilePath: string): Record<string, string>;
     generateAndSaveFiles(yamlFilePath?: string, outputDir?: string, opts?: {

package/dist/generators/serviceGenerator.js

@@ -42,6 +42,22 @@ const generationRegistry_1 = require("../utils/generationRegistry");
 const colors_1 = require("../utils/colors");
 const constants_1 = require("../utils/constants");
 class ServiceGenerator {
+    constructor() {
+        this.availableModels = new Set();
+    }
+    setAvailableModels(models) {
+        this.availableModels.clear();
+        models.forEach(model => {
+            this.availableModels.add(model.name);
+        });
+    }
+    isRelationshipField(field) {
+        return this.availableModels.has(field.type);
+    }
+    getForeignKeyFieldName(field) {
+        // Convention: fieldName + 'Id' (e.g., owner -> ownerId)
+        return field.name + 'Id';
+    }
     hasPermissions(config) {
         if (config.modules) {
             return Object.values(config.modules).some(module => module.permissions && module.permissions.length > 0);
@@ -198,12 +214,17 @@ class ServiceGenerator {
                                 .replace(/{{ENTITY_LOWER}}/g, entityLower);
                             // Handle constructor args for create action
                             if (actionName === 'create') {
+                                const relationshipLoading = this.generateRelationshipLoading(moduleConfig, entityName);
                                 const constructorArgs = this.generateConstructorArgs(moduleConfig, entityName);
+                                if (relationshipLoading) {
+                                    // Insert relationship loading before the entity creation
+                                    processedTemplate = relationshipLoading + '\n    ' + processedTemplate;
+                                }
                                 processedTemplate = processedTemplate.replace(/{{CONSTRUCTOR_ARGS}}/g, constructorArgs);
                             }
                             // Handle setter calls for update action
                             if (actionName === 'update') {
-                                const setterCalls = this.generateUpdateSetterCalls(moduleConfig, entityName);
+                                const setterCalls = this.generateUpdateSetterCalls(moduleConfig, entityName, true);
                                 processedTemplate = processedTemplate.replace(/{{UPDATE_SETTER_CALLS}}/g, setterCalls);
                             }
                             // Special-case: list action with only owner role → fetch by userId
@@ -305,31 +326,88 @@ class ServiceGenerator {
             return '';
         }
         // Find the correct model by entityName instead of always using first model
-        const model = moduleConfig.models.find(m => m.name === entityName) || moduleConfig.models[0];
+        const model = moduleConfig.models.find((m) => m.name === entityName) || moduleConfig.models[0];
         const entityLower = entityName.toLowerCase();
         // Sort fields to match the constructor parameter order
         const sortedFields = this.sortFieldsByRequired(model.fields);
-        return sortedFields
+        const args = [];
+        sortedFields
             .filter(field => !field.auto && field.name !== 'id')
-            .map(field => `${entityLower}Data.${field.name}`)
-            .join(', ');
+            .forEach(field => {
+            // For relationship fields, reference the loaded object variable
+            if (this.isRelationshipField(field)) {
+                args.push(`${field.name}Object`);
+            }
+            else {
+                args.push(`${entityLower}Data.${field.name}`);
+            }
+        });
+        return args.join(', ');
     }
-    generateUpdateSetterCalls(moduleConfig, entityName) {
+    generateRelationshipLoading(moduleConfig, entityName) {
+        if (!moduleConfig.models || moduleConfig.models.length === 0) {
+            return '';
+        }
+        const model = moduleConfig.models.find((m) => m.name === entityName) || moduleConfig.models[0];
+        const entityLower = entityName.toLowerCase();
+        const relationshipFields = model.fields.filter(f => this.isRelationshipField(f));
+        if (relationshipFields.length === 0) {
+            return '';
+        }
+        const loadingCode = relationshipFields.map(field => {
+            const foreignKeyName = this.getForeignKeyFieldName(field);
+            const relatedModel = field.type;
+            const relatedModelLower = relatedModel.toLowerCase();
+            const varName = `${field.name}Object`;
+            if (field.required) {
+                return `const ${varName} = await this.${relatedModelLower}Store.getById(${entityLower}Data.${foreignKeyName});
+    if (!${varName}) {
+      throw new Error('${relatedModel} not found with id ' + ${entityLower}Data.${foreignKeyName});
+    }`;
+            }
+            else {
+                return `const ${varName} = ${entityLower}Data.${foreignKeyName} 
+      ? await this.${relatedModelLower}Store.getById(${entityLower}Data.${foreignKeyName})
+      : null;`;
+            }
+        }).join('\n    ');
+        return '    // Load relationship objects\n    ' + loadingCode;
+    }
+    generateUpdateSetterCalls(moduleConfig, entityName, includeRelationshipLoading = false) {
         if (!moduleConfig.models || moduleConfig.models.length === 0) {
             return '';
         }
         // Find the correct model by entityName instead of always using first model
         const model = moduleConfig.models.find(m => m.name === entityName) || moduleConfig.models[0];
         const entityLower = entityName.toLowerCase();
-        return model.fields
+        let code = '';
+        // Add relationship loading if requested
+        if (includeRelationshipLoading) {
+            const relationshipLoading = this.generateRelationshipLoading(moduleConfig, entityName);
+            if (relationshipLoading) {
+                code = relationshipLoading + '\n    ';
+            }
+        }
+        const setterCalls = model.fields
             .filter(field => !field.auto && field.name !== 'id')
             .map(field => {
-            const methodName = `set${field.name.charAt(0).toUpperCase() + field.name.slice(1)}`;
-            return `if (${entityLower}Data.${field.name} !== undefined) {
+            // For relationship fields, set the loaded object
+            if (this.isRelationshipField(field)) {
+                const foreignKeyName = this.getForeignKeyFieldName(field);
+                const methodName = `set${field.name.charAt(0).toUpperCase() + field.name.slice(1)}`;
+                return `if (${entityLower}Data.${foreignKeyName} !== undefined) {
+      existing${entityName}.${methodName}(${field.name}Object);
+    }`;
+            }
+            else {
+                const methodName = `set${field.name.charAt(0).toUpperCase() + field.name.slice(1)}`;
+                return `if (${entityLower}Data.${field.name} !== undefined) {
       existing${entityName}.${methodName}(${entityLower}Data.${field.name});
     }`;
+            }
         })
             .join('\n    ');
+        return code + setterCalls;
     }
     replaceTemplateVars(template, variables) {
         let result = template;
@@ -407,12 +485,17 @@ class ServiceGenerator {
                     .replace(/{{ENTITY_LOWER}}/g, entityLower);
                 // Handle constructor args for create action
                 if (actionName === 'create') {
+                    const relationshipLoading = this.generateRelationshipLoading(moduleConfig, entityName);
                     const constructorArgs = this.generateConstructorArgs(moduleConfig, entityName);
+                    if (relationshipLoading) {
+                        // Insert relationship loading before the entity creation
+                        methodImplementation = relationshipLoading + '\n    ' + methodImplementation;
+                    }
                     methodImplementation = methodImplementation.replace(/{{CONSTRUCTOR_ARGS}}/g, constructorArgs);
                 }
                 // Handle setter calls for update action
                 if (actionName === 'update') {
-                    const setterCalls = this.generateUpdateSetterCalls(moduleConfig, entityName);
+                    const setterCalls = this.generateUpdateSetterCalls(moduleConfig, entityName, true);
                     methodImplementation = methodImplementation.replace(/{{UPDATE_SETTER_CALLS}}/g, setterCalls);
                 }
                 // Special-case: list action with only owner role → fetch by userId
@@ -478,17 +561,20 @@ class ServiceGenerator {
         })
             .filter(method => method) // Remove empty methods
             .join('\n\n');
+        // Add foreign store constructor params
+        const foreignStoreParams = this.generateForeignStoreConstructorParams(model);
         const serviceClass = this.replaceTemplateVars(serviceTemplates_1.serviceTemplates.serviceClass, {
             ENTITY_NAME: entityName,
             ENTITY_LOWER: entityLower,
-            AUTH_SERVICE_PARAM: '',
+            AUTH_SERVICE_PARAM: foreignStoreParams,
             SERVICE_METHODS: serviceMethods
         });
         const customImports = this.generateCustomImports(moduleConfig);
+        const foreignStoreImports = this.generateForeignStoreImports(model);
         return this.replaceTemplateVars(serviceTemplates_1.serviceFileTemplate, {
             ENTITY_NAME: entityName,
             PERMISSIONS_IMPORT: hasPermissions ? "\nimport type { AuthenticatedUser } from '@currentjs/router';" : '',
-            CUSTOM_IMPORTS: customImports,
+            CUSTOM_IMPORTS: customImports + foreignStoreImports,
             SERVICE_CLASS: serviceClass
         });
     }
@@ -499,6 +585,29 @@ class ServiceGenerator {
         }
         return this.generateServiceForModel(moduleConfig.models[0], moduleName, moduleConfig, hasGlobalPermissions);
     }
+    generateForeignStoreImports(model) {
+        const relationshipFields = model.fields.filter(f => this.isRelationshipField(f));
+        if (relationshipFields.length === 0) {
+            return '';
+        }
+        const imports = relationshipFields.map(field => {
+            const relatedModel = field.type;
+            return `import { ${relatedModel}Store } from '../../infrastructure/stores/${relatedModel}Store';`;
+        });
+        return '\n' + imports.join('\n');
+    }
+    generateForeignStoreConstructorParams(model) {
+        const relationshipFields = model.fields.filter(f => this.isRelationshipField(f));
+        if (relationshipFields.length === 0) {
+            return '';
+        }
+        const params = relationshipFields.map(field => {
+            const relatedModel = field.type;
+            const relatedModelLower = relatedModel.toLowerCase();
+            return `,\n    private ${relatedModelLower}Store: ${relatedModel}Store`;
+        });
+        return params.join('');
+    }
     generateCustomImports(moduleConfig) {
         if (!moduleConfig.actions)
             return '';
@@ -524,6 +633,8 @@ class ServiceGenerator {
         if (config.modules) {
             Object.entries(config.modules).forEach(([moduleName, moduleConfig]) => {
                 if (moduleConfig.models && moduleConfig.models.length > 0) {
+                    // Set available models for relationship detection
+                    this.setAvailableModels(moduleConfig.models);
                     // Generate a service for each model
                     moduleConfig.models.forEach(model => {
                         const serviceCode = this.generateServiceForModel(model, moduleName, moduleConfig, hasGlobalPermissions);
@@ -538,6 +649,8 @@ class ServiceGenerator {
             const moduleName = 'Module';
             const moduleConfig = config;
             if (moduleConfig.models && moduleConfig.models.length > 0) {
+                // Set available models for relationship detection
+                this.setAvailableModels(moduleConfig.models);
                 // Generate a service for each model
                 moduleConfig.models.forEach(model => {
                     const serviceCode = this.generateServiceForModel(model, moduleName, moduleConfig, hasGlobalPermissions);

package/dist/generators/storeGenerator.d.ts

@@ -4,6 +4,7 @@ interface FieldConfig {
     required?: boolean;
     unique?: boolean;
     auto?: boolean;
+    displayFields?: string[];
 }
 interface ModelConfig {
     name: string;
@@ -11,7 +12,11 @@ interface ModelConfig {
 }
 export declare class StoreGenerator {
     private typeMapping;
+    private availableModels;
     private mapType;
+    private setAvailableModels;
+    private isRelationshipField;
+    private getForeignKeyFieldName;
     private generateRowFields;
     private generateFilterableFields;
     private generateFilterableFieldsArray;
@@ -21,6 +26,9 @@ export declare class StoreGenerator {
     private generateModelToRowMapping;
     private replaceTemplateVars;
     generateStoreInterface(): string;
+    private generateRelationshipMethods;
+    private generateStoreConstructorParams;
+    private generateRelationshipImports;
     generateStore(modelConfig: ModelConfig): string;
     generateStores(models: ModelConfig[]): Record<string, string>;
     generateFromYamlFile(yamlFilePath: string): Record<string, string>;

package/dist/generators/storeGenerator.js

@@ -52,20 +52,52 @@ class StoreGenerator {
             array: 'any[]',
             object: 'object'
         };
+        this.availableModels = new Set();
     }
-    mapType(yamlType) {
+    mapType(yamlType, isRelationship = false) {
+        // For relationships, we store the foreign key (number) in the database
+        if (isRelationship) {
+            return 'number';
+        }
+        // Check if this is a known model (relationship) - should use foreign key type
+        if (this.availableModels.has(yamlType)) {
+            return 'number'; // Foreign keys are numbers
+        }
         return this.typeMapping[yamlType] || 'any';
     }
+    setAvailableModels(models) {
+        this.availableModels.clear();
+        models.forEach(model => {
+            this.availableModels.add(model.name);
+        });
+    }
+    isRelationshipField(field) {
+        return this.availableModels.has(field.type);
+    }
+    getForeignKeyFieldName(field) {
+        // Convention: fieldName + 'Id' (e.g., owner -> ownerId)
+        return field.name + 'Id';
+    }
     generateRowFields(modelConfig) {
         const fields = [];
         modelConfig.fields.forEach(field => {
             if (field.name === 'createdAt') {
                 return;
             }
-            const tsType = this.mapType(field.type);
-            const isOptional = !field.required && !field.auto;
-            const fieldDef = `  ${field.name}${isOptional ? '?' : ''}: ${tsType};`;
-            fields.push(fieldDef);
+            // For relationship fields, store the foreign key instead
+            if (this.isRelationshipField(field)) {
+                const foreignKeyName = this.getForeignKeyFieldName(field);
+                const tsType = 'number'; // Foreign keys are always numbers
+                const isOptional = !field.required && !field.auto;
+                const fieldDef = `  ${foreignKeyName}${isOptional ? '?' : ''}: ${tsType};`;
+                fields.push(fieldDef);
+            }
+            else {
+                const tsType = this.mapType(field.type);
+                const isOptional = !field.required && !field.auto;
+                const fieldDef = `  ${field.name}${isOptional ? '?' : ''}: ${tsType};`;
+                fields.push(fieldDef);
+            }
         });
         return fields.join('\n');
     }
@@ -106,6 +138,10 @@ class StoreGenerator {
             if (field.name === 'createdAt') {
                 return '      row.created_at';
             }
+            // For relationship fields, we pass null - will be loaded separately
+            if (this.isRelationshipField(field)) {
+                return '      null as any'; // Placeholder, loaded via loadRelationships
+            }
             return `      row.${field.name}`;
         });
         return mappings.join(',\n');
@@ -115,6 +151,11 @@ class StoreGenerator {
             if (field.name === 'createdAt') {
                 return '      created_at: model.createdAt';
             }
+            // For relationship fields, extract ID from the object to store as FK
+            if (this.isRelationshipField(field)) {
+                const foreignKeyName = this.getForeignKeyFieldName(field);
+                return `      ${foreignKeyName}: model.${field.name}?.id`;
+            }
             return `      ${field.name}: model.${field.name}`;
         });
         return mappings.join(',\n');
@@ -130,6 +171,76 @@ class StoreGenerator {
     generateStoreInterface() {
         return storeTemplates_1.fileTemplates.storeInterface;
     }
+    generateRelationshipMethods(modelConfig) {
+        const relationshipFields = modelConfig.fields.filter(f => this.isRelationshipField(f));
+        if (relationshipFields.length === 0) {
+            return '';
+        }
+        const entityName = modelConfig.name;
+        const methods = [];
+        // Generate loadRelationships method
+        const loadCalls = relationshipFields.map(field => {
+            const foreignKeyName = this.getForeignKeyFieldName(field);
+            const relatedModel = field.type;
+            const relatedModelLower = relatedModel.toLowerCase();
+            return `    if (entity.${field.name} === null && row.${foreignKeyName}) {
+      const ${field.name} = await this.${relatedModelLower}Store.getById(row.${foreignKeyName});
+      if (${field.name}) {
+        entity.set${field.name.charAt(0).toUpperCase() + field.name.slice(1)}(${field.name});
+      }
+    }`;
+        }).join('\n');
+        methods.push(`
+  async loadRelationships(entity: ${entityName}, row: ${entityName}Row): Promise<${entityName}> {
+${loadCalls}
+    return entity;
+  }`);
+        // Generate getByIdWithRelationships method
+        methods.push(`
+  async getByIdWithRelationships(id: number): Promise<${entityName} | null> {
+    try {
+      const query = 'SELECT * FROM ${entityName.toLowerCase()}s WHERE id = :id AND deleted_at IS NULL';
+      const result = await this.db.query(query, { id });
+      
+      if (!result.success || result.data.length === 0) {
+        return null;
+      }
+      
+      const row = result.data[0] as ${entityName}Row;
+      const entity = ${entityName}Store.rowToModel(row);
+      return await this.loadRelationships(entity, row);
+    } catch (error) {
+      if (error instanceof MySQLConnectionError) {
+        throw new Error(\`Database connection error while fetching ${entityName} with id \${id}: \${error.message}\`);
+      } else if (error instanceof MySQLQueryError) {
+        throw new Error(\`Query error while fetching ${entityName} with id \${id}: \${error.message}\`);
+      }
+      throw error;
+    }
+  }`);
+        return methods.join('\n');
+    }
+    generateStoreConstructorParams(modelConfig) {
+        const relationshipFields = modelConfig.fields.filter(f => this.isRelationshipField(f));
+        const params = ['private db: ISqlProvider'];
+        relationshipFields.forEach(field => {
+            const relatedModel = field.type;
+            const relatedModelLower = relatedModel.toLowerCase();
+            params.push(`private ${relatedModelLower}Store: ${relatedModel}Store`);
+        });
+        return params.join(', ');
+    }
+    generateRelationshipImports(modelConfig) {
+        const relationshipFields = modelConfig.fields.filter(f => this.isRelationshipField(f));
+        if (relationshipFields.length === 0) {
+            return '';
+        }
+        const imports = relationshipFields.map(field => {
+            const relatedModel = field.type;
+            return `import { ${relatedModel}Store } from './${relatedModel}Store';`;
+        });
+        return '\n' + imports.join('\n');
+    }
     generateStore(modelConfig) {
         const entityName = modelConfig.name;
         const tableName = entityName.toLowerCase() + 's';
@@ -145,15 +256,26 @@ class StoreGenerator {
         };
         const rowInterface = this.replaceTemplateVars(storeTemplates_1.storeTemplates.rowInterface, variables);
         const conversionMethods = this.replaceTemplateVars(storeTemplates_1.storeTemplates.conversionMethods, variables);
-        const storeClass = this.replaceTemplateVars(storeTemplates_1.storeTemplates.storeClass, {
+        // Replace constructor in storeClass template
+        let storeClass = this.replaceTemplateVars(storeTemplates_1.storeTemplates.storeClass, {
             ...variables,
             CONVERSION_METHODS: conversionMethods
         });
+        // Update constructor to include foreign store dependencies
+        const constructorParams = this.generateStoreConstructorParams(modelConfig);
+        storeClass = storeClass.replace('constructor(private db: ISqlProvider) {}', `constructor(${constructorParams}) {}`);
+        // Add relationship methods before the closing brace
+        const relationshipMethods = this.generateRelationshipMethods(modelConfig);
+        if (relationshipMethods) {
+            storeClass = storeClass.replace(/}$/, `${relationshipMethods}\n}`);
+        }
+        // Add relationship store imports
+        const relationshipImports = this.generateRelationshipImports(modelConfig);
         return this.replaceTemplateVars(storeTemplates_1.fileTemplates.storeFile, {
             ENTITY_NAME: entityName,
             ROW_INTERFACE: rowInterface,
             STORE_CLASS: storeClass
-        });
+        }) + relationshipImports;
     }
     generateStores(models) {
         const result = {};
@@ -169,6 +291,8 @@ class StoreGenerator {
         if (config.modules) {
             Object.values(config.modules).forEach(moduleConfig => {
                 if (moduleConfig.models && moduleConfig.models.length > 0) {
+                    // Set available models for relationship detection
+                    this.setAvailableModels(moduleConfig.models);
                     const stores = this.generateStores(moduleConfig.models);
                     Object.assign(result, stores);
                 }
@@ -177,6 +301,8 @@ class StoreGenerator {
         else if (config.models) {
             const module = config;
             if (module.models && module.models.length > 0) {
+                // Set available models for relationship detection
+                this.setAvailableModels(module.models);
                 const stores = this.generateStores(module.models);
                 Object.assign(result, stores);
             }

package/dist/generators/templateGenerator.d.ts

@@ -1,4 +1,23 @@
 export declare class TemplateGenerator {
+    /**
+     * Helper method to infer model from action handlers
+     */
+    private inferModelFromAction;
+    /**
+     * Find the actual API endpoint path for a given action and model
+     */
+    private findApiEndpointPath;
+    /**
+     * Build relationship context for finding create routes and list API endpoints
+     */
+    private buildRelationshipContext;
+    /**
+     * Generate templates for a single routes configuration
+     */
+    private generateForRoutesConfig;
+    /**
+     * Generate templates for a module (handles both single routes object and array)
+     */
     private generateForModule;
     generateFromYamlFile(yamlFilePath: string): Record<string, {
         file: string;