@currentjs/gen 0.5.0 → 0.5.2

package/dist/generators/serviceGenerator.js

@@ -49,13 +49,146 @@ class ServiceGenerator {
     mapType(yamlType) {
         return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates);
     }
-    generateListHandler(modelName, storeName) {
-        return `  async list(page: number = 1, limit: number = 20): Promise<{ items: ${modelName}[]; total: number; page: number; limit: number }> {
+    getDefaultHandlerReturnType(actionName, modelName) {
+        switch (actionName) {
+            case 'create':
+            case 'get':
+            case 'update':
+                return modelName;
+            case 'delete':
+                return '{ success: boolean; message: string }';
+            case 'list':
+                return `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
+            default:
+                return modelName;
+        }
+    }
+    buildHandlerContextMap(modelName, useCases) {
+        const contextMap = new Map();
+        Object.entries(useCases).forEach(([actionName, useCaseConfig]) => {
+            const inputDtoType = `${modelName}${(0, typeUtils_1.capitalize)(actionName)}Input`;
+            let useCaseReturnType;
+            if (useCaseConfig.output === 'void') {
+                useCaseReturnType = '{ success: boolean; message: string }';
+            }
+            else if (actionName === 'list') {
+                useCaseReturnType = `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
+            }
+            else {
+                useCaseReturnType = modelName;
+            }
+            useCaseConfig.handlers.forEach((handler, index) => {
+                const isFirst = index === 0;
+                const isLast = index === useCaseConfig.handlers.length - 1;
+                let prevHandlerReturnType = null;
+                if (!isFirst) {
+                    const prevHandler = useCaseConfig.handlers[index - 1];
+                    if (prevHandler.startsWith('default:')) {
+                        prevHandlerReturnType = this.getDefaultHandlerReturnType(prevHandler.replace('default:', ''), modelName);
+                    }
+                    else {
+                        prevHandlerReturnType = modelName;
+                    }
+                }
+                const context = {
+                    actionName,
+                    index,
+                    isFirst,
+                    isLast,
+                    prevHandlerReturnType,
+                    inputDtoType,
+                    useCaseReturnType,
+                    inputConfig: useCaseConfig.input
+                };
+                const existing = contextMap.get(handler) || [];
+                existing.push(context);
+                contextMap.set(handler, existing);
+            });
+        });
+        return contextMap;
+    }
+    deriveInputType(contexts) {
+        const inputTypes = [...new Set(contexts.map(c => c.inputDtoType))];
+        return inputTypes.join(' | ');
+    }
+    deriveCustomHandlerTypes(contexts, modelName) {
+        const inputTypes = [...new Set(contexts.map(c => c.inputDtoType))];
+        const resultTypeParts = new Set();
+        contexts.forEach(c => {
+            if (c.isFirst) {
+                resultTypeParts.add('null');
+            }
+            if (c.prevHandlerReturnType) {
+                resultTypeParts.add(c.prevHandlerReturnType);
+            }
+        });
+        const returnTypeParts = new Set();
+        contexts.forEach(c => {
+            if (c.isLast) {
+                returnTypeParts.add(c.useCaseReturnType);
+            }
+            else {
+                returnTypeParts.add(modelName);
+            }
+        });
+        return {
+            inputType: inputTypes.join(' | '),
+            resultType: [...resultTypeParts].join(' | '),
+            returnType: [...returnTypeParts].join(' | ')
+        };
+    }
+    getInputDtoFields(inputConfig, aggregateConfig, childInfo) {
+        const fields = new Set();
+        if (!inputConfig)
+            return fields;
+        if (!inputConfig.identifier && !inputConfig.partial) {
+            fields.add(childInfo ? childInfo.parentIdField : 'ownerId');
+        }
+        if (inputConfig.from) {
+            let fieldNames = Object.keys(aggregateConfig.fields)
+                .filter(f => !aggregateConfig.fields[f].auto && f !== 'id');
+            if (inputConfig.pick && inputConfig.pick.length > 0) {
+                fieldNames = fieldNames.filter(f => inputConfig.pick.includes(f));
+            }
+            if (inputConfig.omit && inputConfig.omit.length > 0) {
+                fieldNames = fieldNames.filter(f => !inputConfig.omit.includes(f));
+            }
+            fieldNames.forEach(f => fields.add(f));
+        }
+        if (inputConfig.add) {
+            Object.keys(inputConfig.add).forEach(f => fields.add(f));
+        }
+        return fields;
+    }
+    computeDtoFieldsForHandler(contexts, aggregateConfig, childInfo) {
+        const fieldSets = contexts.map(ctx => this.getInputDtoFields(ctx.inputConfig, aggregateConfig, childInfo));
+        if (fieldSets.length === 0) {
+            return new Set(Object.keys(aggregateConfig.fields).filter(f => !aggregateConfig.fields[f].auto && f !== 'id'));
+        }
+        const result = new Set(fieldSets[0]);
+        for (let i = 1; i < fieldSets.length; i++) {
+            for (const field of result) {
+                if (!fieldSets[i].has(field)) {
+                    result.delete(field);
+                }
+            }
+        }
+        return result;
+    }
+    generateListHandler(modelName, storeName, hasPagination) {
+        const returnType = `{ items: ${modelName}[]; total: number; page: number; limit: number }`;
+        if (hasPagination) {
+            return `  async list(page: number = 1, limit: number = 20, ownerId?: number): Promise<${returnType}> {
     const [items, total] = await Promise.all([
-      this.${storeName}.getAll(page, limit),
-      this.${storeName}.count()
+      this.${storeName}.getPaginated(page, limit, ownerId),
+      this.${storeName}.count(ownerId)
     ]);
     return { items, total, page, limit };
+  }`;
+        }
+        return `  async list(ownerId?: number): Promise<${returnType}> {
+    const items = await this.${storeName}.getAll(ownerId);
+    return { items, total: items.length, page: 1, limit: items.length };
   }`;
     }
     generateGetHandler(modelName, storeName, entityLower) {
@@ -67,35 +200,60 @@ class ServiceGenerator {
     return ${entityLower};
   }`;
     }
-    generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo) {
+    generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo, inputType, dtoFields) {
         const firstArgField = childInfo ? childInfo.parentIdField : 'ownerId';
         const fields = Object.entries(aggregateConfig.fields)
             .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id')
             .sort((a, b) => {
-            const aRequired = a[1].required !== false;
-            const bRequired = b[1].required !== false;
+            const aIsAggRef = (0, typeUtils_1.isAggregateReference)(a[1].type, this.availableAggregates);
+            const bIsAggRef = (0, typeUtils_1.isAggregateReference)(b[1].type, this.availableAggregates);
+            const aRequired = a[1].required !== false && !aIsAggRef;
+            const bRequired = b[1].required !== false && !bIsAggRef;
             if (aRequired === bRequired)
                 return 0;
             return aRequired ? -1 : 1;
         });
-        const fieldArgs = fields.map(([fieldName]) => `input.${fieldName}`).join(', ');
+        const fieldArgs = fields.map(([fieldName, fieldConfig]) => {
+            if (!dtoFields.has(fieldName)) {
+                return 'undefined';
+            }
+            if ((0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates)) {
+                return `input.${fieldName} != null ? ({ id: input.${fieldName} } as unknown as ${fieldConfig.type}) : undefined`;
+            }
+            if (fieldConfig.type === 'enum' && fieldConfig.values && fieldConfig.values.length > 0) {
+                const enumTypeName = `${modelName}${(0, typeUtils_1.capitalize)(fieldName)}`;
+                return `input.${fieldName} as ${enumTypeName}`;
+            }
+            return `input.${fieldName}`;
+        }).join(', ');
         const constructorArgs = `input.${firstArgField}, ${fieldArgs}`;
-        return `  async create(input: any): Promise<${modelName}> {
+        return `  async create(input: ${inputType}): Promise<${modelName}> {
     const ${entityLower} = new ${modelName}(0, ${constructorArgs});
     return await this.${storeName}.insert(${entityLower});
   }`;
     }
-    generateUpdateHandler(modelName, storeName, aggregateConfig) {
+    generateUpdateHandler(modelName, storeName, aggregateConfig, inputType, dtoFields) {
         const setterCalls = Object.entries(aggregateConfig.fields)
-            .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id')
-            .map(([fieldName]) => {
+            .filter(([fieldName, fieldConfig]) => !fieldConfig.auto && fieldName !== 'id' && dtoFields.has(fieldName))
+            .map(([fieldName, fieldConfig]) => {
             const methodName = `set${(0, typeUtils_1.capitalize)(fieldName)}`;
+            if ((0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates)) {
+                return `    if (input.${fieldName} !== undefined) {
+      existing${modelName}.${methodName}(input.${fieldName} != null ? ({ id: input.${fieldName} } as unknown as ${fieldConfig.type}) : undefined);
+    }`;
+            }
+            if (fieldConfig.type === 'enum' && fieldConfig.values && fieldConfig.values.length > 0) {
+                const enumTypeName = `${modelName}${(0, typeUtils_1.capitalize)(fieldName)}`;
+                return `    if (input.${fieldName} !== undefined) {
+      existing${modelName}.${methodName}(input.${fieldName} as ${enumTypeName});
+    }`;
+            }
             return `    if (input.${fieldName} !== undefined) {
       existing${modelName}.${methodName}(input.${fieldName});
     }`;
         })
             .join('\n');
-        return `  async update(id: number, input: any): Promise<${modelName}> {
+        return `  async update(id: number, input: ${inputType}): Promise<${modelName}> {
     const existing${modelName} = await this.${storeName}.getById(id);
     if (!existing${modelName}) {
       throw new Error('${modelName} not found');
@@ -115,29 +273,30 @@ ${setterCalls}
     return { success: true, message: '${modelName} deleted successfully' };
   }`;
     }
-    generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo) {
+    generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo, inputType, dtoFields, listConfig) {
+        var _a;
         const entityLower = modelName.toLowerCase();
         const storeName = `${entityLower}Store`;
         switch (actionName) {
             case 'list':
-                return this.generateListHandler(modelName, storeName);
+                return this.generateListHandler(modelName, storeName, (_a = listConfig === null || listConfig === void 0 ? void 0 : listConfig.hasPagination) !== null && _a !== void 0 ? _a : true);
             case 'get':
                 return this.generateGetHandler(modelName, storeName, entityLower);
             case 'create':
-                return this.generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo);
+                return this.generateCreateHandler(modelName, storeName, entityLower, aggregateConfig, childInfo, inputType, dtoFields);
             case 'update':
-                return this.generateUpdateHandler(modelName, storeName, aggregateConfig);
+                return this.generateUpdateHandler(modelName, storeName, aggregateConfig, inputType, dtoFields);
             case 'delete':
                 return this.generateDeleteHandler(modelName, storeName);
             default:
-                return `  async ${actionName}(input: any): Promise<any> {
+                return `  async ${actionName}(input: ${inputType}): Promise<${modelName}> {
     // TODO: Implement default ${actionName} handler
     throw new Error('Not implemented');
   }`;
         }
     }
-    generateCustomHandlerMethod(modelName, handlerName) {
-        return `  async ${handlerName}(result: any, input: any): Promise<any> {
+    generateCustomHandlerMethod(modelName, handlerName, resultType, inputType, returnType) {
+        return `  async ${handlerName}(result: ${resultType}, input: ${inputType}): Promise<${returnType}> {
     // TODO: Implement custom ${handlerName} handler
     // This method receives the result from the previous handler (or null if first)
     // and the input context
@@ -177,17 +336,41 @@ ${setterCalls}
         const serviceName = `${modelName}Service`;
         const storeName = `${modelName}Store`;
         const storeVar = `${modelName.toLowerCase()}Store`;
+        // Build handler-to-context map for type inference
+        const handlerContextMap = this.buildHandlerContextMap(modelName, useCases);
         // Collect all unique handlers
         const handlers = this.collectHandlers(useCases);
+        // Collect DTO types needed for imports
+        const dtoTypes = new Set();
+        const enumTypeNames = new Set();
         // Generate methods for each handler
         const methods = [];
         handlers.forEach(handler => {
+            var _a, _b;
+            const contexts = handlerContextMap.get(handler) || [];
             if (handler.startsWith('default:')) {
                 const actionName = handler.replace('default:', '');
-                methods.push(this.generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo));
+                const inputType = this.deriveInputType(contexts);
+                const dtoFields = this.computeDtoFieldsForHandler(contexts, aggregateConfig, childInfo);
+                if (actionName !== 'list' && actionName !== 'get' && actionName !== 'delete') {
+                    contexts.forEach(c => dtoTypes.add(c.inputDtoType));
+                }
+                if (actionName === 'create' || actionName === 'update') {
+                    for (const [fieldName, fieldConfig] of Object.entries(aggregateConfig.fields)) {
+                        if (fieldConfig.type === 'enum' && fieldConfig.values && fieldConfig.values.length > 0 && dtoFields.has(fieldName)) {
+                            enumTypeNames.add(`${modelName}${(0, typeUtils_1.capitalize)(fieldName)}`);
+                        }
+                    }
+                }
+                const listConfig = actionName === 'list'
+                    ? { hasPagination: !!((_b = (_a = contexts[0]) === null || _a === void 0 ? void 0 : _a.inputConfig) === null || _b === void 0 ? void 0 : _b.pagination) }
+                    : undefined;
+                methods.push(this.generateDefaultHandlerMethod(modelName, actionName, aggregateConfig, childInfo, inputType, dtoFields, listConfig));
             }
             else {
-                methods.push(this.generateCustomHandlerMethod(modelName, handler));
+                const { inputType, resultType, returnType } = this.deriveCustomHandlerTypes(contexts, modelName);
+                contexts.forEach(c => dtoTypes.add(c.inputDtoType));
+                methods.push(this.generateCustomHandlerMethod(modelName, handler, resultType, inputType, returnType));
             }
         });
         const listByParentMethod = this.generateListByParentMethod(modelName, childInfo);
@@ -198,8 +381,21 @@ ${setterCalls}
         if (getResourceOwnerMethod) {
             methods.push(getResourceOwnerMethod);
         }
+        // Collect imports for aggregate reference types used in fields
+        const aggRefImports = Object.entries(aggregateConfig.fields)
+            .filter(([, fc]) => (0, typeUtils_1.isAggregateReference)(fc.type, this.availableAggregates) && fc.type !== modelName)
+            .map(([, fc]) => `import { ${fc.type} } from '../../domain/entities/${fc.type}';`)
+            .filter((imp, idx, arr) => arr.indexOf(imp) === idx);
+        const aggRefImportStr = aggRefImports.length > 0 ? '\n' + aggRefImports.join('\n') : '';
+        // Generate DTO import statements
+        const dtoImports = [...dtoTypes].map(dtoType => {
+            const fileSuffix = dtoType.replace(modelName, '').replace('Input', '');
+            return `import { ${dtoType} } from '../dto/${modelName}${fileSuffix}';`;
+        }).join('\n');
+        const dtoImportStr = dtoImports ? '\n' + dtoImports : '';
+        const entityImports = [modelName, ...enumTypeNames].join(', ');
         return `import { Injectable } from '../../../../system';
-import { ${modelName} } from '../../domain/entities/${modelName}';
+import { ${entityImports} } from '../../domain/entities/${modelName}';${aggRefImportStr}${dtoImportStr}
 import { ${storeName} } from '../../infrastructure/stores/${storeName}';
 
 /**

package/dist/generators/storeGenerator.d.ts

@@ -1,6 +1,8 @@
 import { ModuleConfig } from '../types/configTypes';
 export declare class StoreGenerator {
     private availableValueObjects;
+    private availableAggregates;
+    private isAggregateField;
     private isValueObjectType;
     private getValueObjectName;
     private getValueObjectConfig;
@@ -31,6 +33,8 @@ export declare class StoreGenerator {
     private generateUpdateDataMapping;
     private generateUpdateFieldsArray;
     private generateValueObjectImports;
+    private generateAggregateRefImports;
+    private generateListMethods;
     private generateGetByParentIdMethod;
     private generateGetResourceOwnerMethod;
     private generateStore;

package/dist/generators/storeGenerator.js

@@ -46,6 +46,10 @@ const typeUtils_1 = require("../utils/typeUtils");
 class StoreGenerator {
     constructor() {
         this.availableValueObjects = new Map();
+        this.availableAggregates = new Set();
+    }
+    isAggregateField(fieldConfig) {
+        return (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
     }
     isValueObjectType(fieldType) {
         const capitalizedType = (0, typeUtils_1.capitalize)(fieldType);
@@ -64,8 +68,8 @@ class StoreGenerator {
      */
     sortFieldsForConstructor(fields) {
         return [...fields].sort((a, b) => {
-            const aRequired = a[1].required !== false && !a[1].auto;
-            const bRequired = b[1].required !== false && !b[1].auto;
+            const aRequired = a[1].required !== false && !a[1].auto && !this.isAggregateField(a[1]);
+            const bRequired = b[1].required !== false && !b[1].auto && !this.isAggregateField(b[1]);
             if (aRequired === bRequired)
                 return 0;
             return aRequired ? -1 : 1;
@@ -139,6 +143,10 @@ class StoreGenerator {
         const ownerOrParentField = childInfo ? childInfo.parentIdField : 'ownerId';
         result.push(`  ${ownerOrParentField}: number;`);
         fields.forEach(([fieldName, fieldConfig]) => {
+            if (this.isAggregateField(fieldConfig)) {
+                result.push(`  ${fieldName}_id?: number;`);
+                return;
+            }
             const tsType = this.mapTypeToRowType(fieldConfig.type);
             const isOptional = !fieldConfig.required;
             result.push(`  ${fieldName}${isOptional ? '?' : ''}: ${tsType};`);
@@ -148,15 +156,26 @@ class StoreGenerator {
     generateFieldNamesStr(fields, childInfo) {
         const fieldNames = ['id'];
         fieldNames.push(childInfo ? childInfo.parentIdField : 'ownerId');
-        fieldNames.push(...fields.map(([name]) => name));
+        fieldNames.push(...fields.map(([name, config]) => this.isAggregateField(config) ? `${name}_id` : name));
         return fieldNames.map(f => `\\\`${f}\\\``).join(', ');
     }
-    generateRowToModelMapping(fields, childInfo) {
+    generateRowToModelMapping(modelName, fields, childInfo) {
         const result = [];
         const ownerOrParentField = childInfo ? childInfo.parentIdField : 'ownerId';
         result.push(`      row.${ownerOrParentField}`);
         fields.forEach(([fieldName, fieldConfig]) => {
             const fieldType = fieldConfig.type;
+            // Handle enum type - cast string to the generated union type
+            if (fieldType === 'enum' && fieldConfig.values && fieldConfig.values.length > 0) {
+                const enumTypeName = `${modelName}${(0, typeUtils_1.capitalize)(fieldName)}`;
+                result.push(`      row.${fieldName} as ${enumTypeName}`);
+                return;
+            }
+            // Handle aggregate reference - create stub from FK
+            if (this.isAggregateField(fieldConfig)) {
+                result.push(`      row.${fieldName}_id != null ? ({ id: row.${fieldName}_id } as unknown as ${fieldType}) : undefined`);
+                return;
+            }
             // Handle datetime/date conversion
             if (fieldType === 'datetime' || fieldType === 'date') {
                 result.push(this.generateDatetimeConversion(fieldName, 'toDate'));
@@ -189,6 +208,11 @@ class StoreGenerator {
         result.push(`      ${ownerOrParentField}: entity.${ownerOrParentField}`);
         fields.forEach(([fieldName, fieldConfig]) => {
             const fieldType = fieldConfig.type;
+            // Handle aggregate reference - extract FK id
+            if (this.isAggregateField(fieldConfig)) {
+                result.push(`      ${fieldName}_id: entity.${fieldName}?.id`);
+                return;
+            }
             // Handle datetime/date - convert Date to MySQL DATETIME format
             if (fieldType === 'datetime' || fieldType === 'date') {
                 result.push(this.generateDatetimeConversion(fieldName, 'toMySQL'));
@@ -213,6 +237,9 @@ class StoreGenerator {
         return fields
             .map(([fieldName, fieldConfig]) => {
             const fieldType = fieldConfig.type;
+            if (this.isAggregateField(fieldConfig)) {
+                return `      ${fieldName}_id: entity.${fieldName}?.id`;
+            }
             if (fieldType === 'datetime' || fieldType === 'date') {
                 return this.generateDatetimeConversion(fieldName, 'toMySQL');
             }
@@ -228,7 +255,7 @@ class StoreGenerator {
             .join(',\n');
     }
     generateUpdateFieldsArray(fields) {
-        return JSON.stringify(fields.map(([name]) => name));
+        return JSON.stringify(fields.map(([name, config]) => this.isAggregateField(config) ? `${name}_id` : name));
     }
     generateValueObjectImports(fields) {
         const imports = [];
@@ -255,10 +282,71 @@ class StoreGenerator {
         }
         return '\n' + uniqueImports.join('\n');
     }
+    generateAggregateRefImports(modelName, fields) {
+        const imports = [];
+        fields.forEach(([, fieldConfig]) => {
+            if (this.isAggregateField(fieldConfig) && fieldConfig.type !== modelName) {
+                imports.push(`import { ${fieldConfig.type} } from '../../domain/entities/${fieldConfig.type}';`);
+            }
+        });
+        const uniqueImports = [...new Set(imports)];
+        if (uniqueImports.length === 0)
+            return '';
+        return '\n' + uniqueImports.join('\n');
+    }
+    generateListMethods(modelName, fieldNamesStr, childInfo) {
+        const isRoot = !childInfo;
+        const ownerParam = isRoot ? ', ownerId?: number' : '';
+        const ownerFilter = isRoot
+            ? `\n    const ownerFilter = ownerId != null ? ' AND \\\`ownerId\\\` = :ownerId' : '';`
+            : '';
+        const ownerFilterRef = isRoot ? '\${ownerFilter}' : '';
+        const ownerParamsSetup = isRoot
+            ? `\n    if (ownerId != null) params.ownerId = ownerId;`
+            : '';
+        const getPaginated = `  async getPaginated(page: number = 1, limit: number = 20${ownerParam}): Promise<${modelName}[]> {
+    const offset = (page - 1) * limit;${ownerFilter}
+    const params: Record<string, any> = { limit: String(limit), offset: String(offset) };${ownerParamsSetup}
+    const result = await this.db.query(
+      \`SELECT ${fieldNamesStr} FROM \\\`\${this.tableName}\\\` WHERE deleted_at IS NULL${ownerFilterRef} LIMIT :limit OFFSET :offset\`,
+      params
+    );
+
+    if (result.success && result.data) {
+      return result.data.map((row: ${modelName}Row) => this.rowToModel(row));
+    }
+    return [];
+  }`;
+        const getAll = `  async getAll(${isRoot ? 'ownerId?: number' : ''}): Promise<${modelName}[]> {${ownerFilter}
+    const params: Record<string, any> = {};${ownerParamsSetup}
+    const result = await this.db.query(
+      \`SELECT ${fieldNamesStr} FROM \\\`\${this.tableName}\\\` WHERE deleted_at IS NULL${ownerFilterRef}\`,
+      params
+    );
+
+    if (result.success && result.data) {
+      return result.data.map((row: ${modelName}Row) => this.rowToModel(row));
+    }
+    return [];
+  }`;
+        const count = `  async count(${isRoot ? 'ownerId?: number' : ''}): Promise<number> {${ownerFilter}
+    const params: Record<string, any> = {};${ownerParamsSetup}
+    const result = await this.db.query(
+      \`SELECT COUNT(*) as count FROM \\\`\${this.tableName}\\\` WHERE deleted_at IS NULL${ownerFilterRef}\`,
+      params
+    );
+
+    if (result.success && result.data && result.data.length > 0) {
+      return parseInt(result.data[0].count, 10);
+    }
+    return 0;
+  }`;
+        return `${getPaginated}\n\n${getAll}\n\n${count}`;
+    }
     generateGetByParentIdMethod(modelName, fields, childInfo) {
         if (!childInfo)
             return '';
-        const fieldList = ['id', childInfo.parentIdField, ...fields.map(([name]) => name)].map(f => '\\`' + f + '\\`').join(', ');
+        const fieldList = ['id', childInfo.parentIdField, ...fields.map(([name, config]) => this.isAggregateField(config) ? `${name}_id` : name)].map(f => '\\`' + f + '\\`').join(', ');
         const parentIdField = childInfo.parentIdField;
         return `
 
@@ -319,26 +407,38 @@ class StoreGenerator {
         const fields = Object.entries(aggregateConfig.fields);
         // Sort fields for rowToModel to match entity constructor order (required first, optional second)
         const sortedFields = this.sortFieldsForConstructor(fields);
+        const fieldNamesStr = this.generateFieldNamesStr(fields, childInfo);
         const variables = {
             ENTITY_NAME: modelName,
             TABLE_NAME: tableName,
             ROW_FIELDS: this.generateRowFields(fields, childInfo),
-            FIELD_NAMES: this.generateFieldNamesStr(fields, childInfo),
-            ROW_TO_MODEL_MAPPING: this.generateRowToModelMapping(sortedFields, childInfo),
+            FIELD_NAMES: fieldNamesStr,
+            ROW_TO_MODEL_MAPPING: this.generateRowToModelMapping(modelName, sortedFields, childInfo),
             INSERT_DATA_MAPPING: this.generateInsertDataMapping(fields, childInfo),
             UPDATE_DATA_MAPPING: this.generateUpdateDataMapping(fields),
             UPDATE_FIELDS_ARRAY: this.generateUpdateFieldsArray(fields),
             VALUE_OBJECT_IMPORTS: this.generateValueObjectImports(fields),
+            AGGREGATE_REF_IMPORTS: this.generateAggregateRefImports(modelName, fields),
+            LIST_METHODS: this.generateListMethods(modelName, fieldNamesStr, childInfo),
             GET_BY_PARENT_ID_METHOD: this.generateGetByParentIdMethod(modelName, fields, childInfo),
             GET_RESOURCE_OWNER_METHOD: this.generateGetResourceOwnerMethod(childInfo)
         };
         const rowInterface = this.replaceTemplateVars(storeTemplates_1.storeTemplates.rowInterface, variables);
         const storeClass = this.replaceTemplateVars(storeTemplates_1.storeTemplates.storeClass, variables);
+        // Build entity import items: entity name + any enum type names
+        const entityImportItems = [modelName];
+        fields.forEach(([fieldName, fieldConfig]) => {
+            if (fieldConfig.type === 'enum' && fieldConfig.values && fieldConfig.values.length > 0) {
+                entityImportItems.push(`${modelName}${(0, typeUtils_1.capitalize)(fieldName)}`);
+            }
+        });
         return this.replaceTemplateVars(storeTemplates_1.storeFileTemplate, {
             ENTITY_NAME: modelName,
+            ENTITY_IMPORT_ITEMS: entityImportItems.join(', '),
             ROW_INTERFACE: rowInterface,
             STORE_CLASS: storeClass,
-            VALUE_OBJECT_IMPORTS: variables.VALUE_OBJECT_IMPORTS
+            VALUE_OBJECT_IMPORTS: variables.VALUE_OBJECT_IMPORTS,
+            AGGREGATE_REF_IMPORTS: variables.AGGREGATE_REF_IMPORTS
         });
     }
     generateFromConfig(config) {
@@ -350,6 +450,13 @@ class StoreGenerator {
                 this.availableValueObjects.set(name, voConfig);
             });
         }
+        // Collect all aggregate names for detecting entity references
+        this.availableAggregates.clear();
+        if (config.domain.aggregates) {
+            Object.keys(config.domain.aggregates).forEach(name => {
+                this.availableAggregates.add(name);
+            });
+        }
         // Generate a store for each aggregate
         const childEntityMap = (0, childEntityUtils_1.buildChildEntityMap)(config);
         if (config.domain.aggregates) {

package/dist/generators/templateGenerator.d.ts

@@ -26,5 +26,6 @@ export declare class TemplateGenerator {
     generateAndSaveFiles(yamlFilePath: string, moduleDir: string, opts?: {
         force?: boolean;
         skipOnConflict?: boolean;
+        onlyIfMissing?: boolean;
     }): Promise<void>;
 }

package/dist/generators/templateGenerator.js

@@ -458,16 +458,22 @@ ${options}
         return this.generateFromConfig(config);
     }
     async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
+        let isGenerated = false;
         const templatesByName = this.generateFromYamlFile(yamlFilePath);
         const viewsDir = path.join(moduleDir, 'views');
         fs.mkdirSync(viewsDir, { recursive: true });
         for (const [name, content] of Object.entries(templatesByName)) {
             const filePath = path.join(viewsDir, `${name}.html`);
+            if ((opts === null || opts === void 0 ? void 0 : opts.onlyIfMissing) && fs.existsSync(filePath))
+                continue;
             // eslint-disable-next-line no-await-in-loop
             await (0, generationRegistry_1.writeGeneratedFile)(filePath, content, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
+            isGenerated = true;
+        }
+        if (isGenerated) {
+            // eslint-disable-next-line no-console
+            console.log('\n' + colors_1.colors.green('Template files generated successfully!') + '\n');
         }
-        // eslint-disable-next-line no-console
-        console.log('\n' + colors_1.colors.green('Template files generated successfully!') + '\n');
     }
 }
 exports.TemplateGenerator = TemplateGenerator;

package/dist/generators/templates/appTemplates.js

@@ -60,7 +60,7 @@ const packageJsonTemplate = (appName) => JSON.stringify({
     devDependencies: {
         typescript: '^5.6.3',
         '@types/node': '^22.7.4',
-        '@koz1024/path-fixer': '^0.2.1',
+        '@koz1024/path-fixer': '^0.2.2',
     },
     type: 'module'
 }, null, 2);