@currentjs/gen 0.2.1 → 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);
@@ -102,17 +142,35 @@ class DomainModelGenerator {
         });
         return setterMethods.join('\n');
     }
+    sortFieldsByRequired(fields) {
+        // Sort fields: required fields first, then optional fields
+        return [...fields].sort((a, b) => {
+            const aRequired = a.required !== false && !a.auto;
+            const bRequired = b.required !== false && !b.auto;
+            if (aRequired === bRequired) {
+                return 0; // Keep original order if both have same required status
+            }
+            return aRequired ? -1 : 1; // Required fields come first
+        });
+    }
     generateModel(modelConfig) {
         const className = modelConfig.name;
         // Always add id field first
         const constructorParams = ['public id: number'];
+        // Sort fields to put required fields before optional ones
+        const sortedFields = this.sortFieldsByRequired(modelConfig.fields);
         // Process other fields
-        modelConfig.fields.forEach(field => {
+        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}
     ) { }
@@ -130,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);
                     });
@@ -138,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);
             });
@@ -149,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);
                     });
@@ -156,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;
@@ -24,13 +36,17 @@ export declare class ServiceGenerator {
     private generateMethodImplementation;
     private extractFunctionName;
     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
@@ -288,34 +309,105 @@ class ServiceGenerator {
                 return '/* custom params */';
         }
     }
+    sortFieldsByRequired(fields) {
+        // Sort fields: required fields first, then optional fields
+        // This must match the order used in domainModelGenerator
+        return [...fields].sort((a, b) => {
+            const aRequired = a.required !== false && !a.auto;
+            const bRequired = b.required !== false && !b.auto;
+            if (aRequired === bRequired) {
+                return 0; // Keep original order if both have same required status
+            }
+            return aRequired ? -1 : 1; // Required fields come first
+        });
+    }
     generateConstructorArgs(moduleConfig, entityName) {
         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 model = moduleConfig.models.find((m) => m.name === entityName) || moduleConfig.models[0];
         const entityLower = entityName.toLowerCase();
-        return model.fields
+        // Sort fields to match the constructor parameter order
+        const sortedFields = this.sortFieldsByRequired(model.fields);
+        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(', ');
+    }
+    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) {
+    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;
@@ -393,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
@@ -464,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
         });
     }
@@ -485,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 '';
@@ -510,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);
@@ -524,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,15 +12,23 @@ interface ModelConfig {
 }
 export declare class StoreGenerator {
     private typeMapping;
+    private availableModels;
     private mapType;
+    private setAvailableModels;
+    private isRelationshipField;
+    private getForeignKeyFieldName;
     private generateRowFields;
     private generateFilterableFields;
     private generateFilterableFieldsArray;
     private generateUpdatableFieldsArray;
+    private sortFieldsByRequired;
     private generateRowToModelMapping;
     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>;