@currentjs/gen 0.3.1 → 0.5.0

package/dist/generators/storeGenerator.js

@@ -37,295 +37,348 @@ exports.StoreGenerator = void 0;
 const yaml_1 = require("yaml");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const storeTemplates_1 = require("./templates/storeTemplates");
 const generationRegistry_1 = require("../utils/generationRegistry");
 const colors_1 = require("../utils/colors");
-const constants_1 = require("../utils/constants");
+const configTypes_1 = require("../types/configTypes");
+const childEntityUtils_1 = require("../utils/childEntityUtils");
+const storeTemplates_1 = require("./templates/storeTemplates");
+const typeUtils_1 = require("../utils/typeUtils");
 class StoreGenerator {
     constructor() {
-        this.typeMapping = {
-            string: 'string',
-            number: 'number',
-            boolean: 'boolean',
-            datetime: 'Date',
-            json: 'any',
-            array: 'any[]',
-            object: 'object'
-        };
-        this.availableModels = new Set();
-    }
-    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';
+        this.availableValueObjects = new Map();
     }
-    setAvailableModels(models) {
-        this.availableModels.clear();
-        models.forEach(model => {
-            this.availableModels.add(model.name);
-        });
+    isValueObjectType(fieldType) {
+        const capitalizedType = (0, typeUtils_1.capitalize)(fieldType);
+        return this.availableValueObjects.has(capitalizedType);
     }
-    isRelationshipField(field) {
-        return this.availableModels.has(field.type);
+    getValueObjectName(fieldType) {
+        return (0, typeUtils_1.capitalize)(fieldType);
     }
-    getForeignKeyFieldName(field) {
-        // Convention: fieldName + 'Id' (e.g., owner -> ownerId)
-        return field.name + 'Id';
+    getValueObjectConfig(fieldType) {
+        return this.availableValueObjects.get(this.getValueObjectName(fieldType));
     }
-    generateRowFields(modelConfig) {
-        const fields = [];
-        modelConfig.fields.forEach(field => {
-            if (field.name === 'createdAt') {
-                return;
-            }
-            // 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);
-            }
+    /**
+     * Sort fields the same way as the domain layer generator:
+     * Required fields first, then optional fields.
+     * This ensures rowToModel parameter order matches entity constructor.
+     */
+    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;
+            if (aRequired === bRequired)
+                return 0;
+            return aRequired ? -1 : 1;
         });
-        return fields.join('\n');
     }
-    generateFilterableFields(modelConfig) {
-        const filterableFields = modelConfig.fields
-            .filter(field => ['string', 'number', 'boolean'].includes(field.type))
-            .map(field => `'${field.name}'`);
-        return filterableFields.join(' | ');
+    /**
+     * Gets the type name for a value object field (for casting).
+     * For enum fields, returns the generated type name (e.g., BreedName).
+     * For other fields, returns the basic TypeScript type.
+     */
+    getValueObjectFieldTypeName(voName, voConfig) {
+        const fields = Object.entries(voConfig.fields);
+        // Look for enum fields - they get generated type names
+        for (const [fieldName, fieldConfig] of fields) {
+            if (typeof fieldConfig === 'object' && 'values' in fieldConfig) {
+                // This is an enum field, return the generated type name
+                return `${voName}${(0, typeUtils_1.capitalize)(fieldName)}`;
+            }
+        }
+        return null;
     }
-    generateFilterableFieldsArray(modelConfig) {
-        const filterableFields = modelConfig.fields
-            .filter(field => ['string', 'number', 'boolean'].includes(field.type))
-            .map(field => `'${field.name}'`);
-        return filterableFields.join(', ');
+    mapTypeToRowType(yamlType) {
+        return (0, typeUtils_1.mapRowType)(yamlType, this.availableValueObjects);
     }
-    generateUpdatableFieldsArray(modelConfig) {
-        const updatableFields = modelConfig.fields
-            .filter(field => field.name !== 'id' && field.name !== 'createdAt')
-            .map(field => `'${field.name}'`);
-        return updatableFields.join(', ');
+    /** Single line for serializing a value object field to DB (insert/update). */
+    generateValueObjectSerialization(fieldName, voName, voConfig) {
+        const voFields = Object.keys(voConfig.fields);
+        if (voFields.length > 1) {
+            return `      ${fieldName}: entity.${fieldName} ? JSON.stringify(entity.${fieldName}) : undefined`;
+        }
+        if (voFields.length === 1) {
+            return `      ${fieldName}: entity.${fieldName}?.${voFields[0]}`;
+        }
+        return `      ${fieldName}: entity.${fieldName} ? JSON.stringify(entity.${fieldName}) : undefined`;
     }
-    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
+    /** Single line for deserializing a value object from row (rowToModel). */
+    generateValueObjectDeserialization(fieldName, voName, voConfig) {
+        const voFields = Object.keys(voConfig.fields);
+        if (voFields.length > 1) {
+            const voArgs = voFields.map(f => `parsed.${f}`).join(', ');
+            return `      row.${fieldName} ? (() => { const parsed = JSON.parse(row.${fieldName}); return new ${voName}(${voArgs}); })() : undefined`;
+        }
+        if (voFields.length === 1) {
+            const singleFieldType = voConfig.fields[voFields[0]];
+            const hasEnumValues = typeof singleFieldType === 'object' && 'values' in singleFieldType;
+            if (hasEnumValues) {
+                const enumTypeName = this.getValueObjectFieldTypeName(voName, voConfig);
+                return `      row.${fieldName} ? new ${voName}(row.${fieldName} as ${enumTypeName}) : undefined`;
             }
-            return aRequired ? -1 : 1; // Required fields come first
+            return `      row.${fieldName} ? new ${voName}(row.${fieldName}) : undefined`;
+        }
+        return `      row.${fieldName} ? new ${voName}(...Object.values(JSON.parse(row.${fieldName}))) : undefined`;
+    }
+    /** Single line for datetime conversion: toDate (row->model) or toMySQL (entity->row). */
+    generateDatetimeConversion(fieldName, direction) {
+        if (direction === 'toDate') {
+            return `      row.${fieldName} ? new Date(row.${fieldName}) : undefined`;
+        }
+        return `      ${fieldName}: entity.${fieldName} ? this.toMySQLDatetime(entity.${fieldName}) : undefined`;
+    }
+    replaceTemplateVars(template, variables) {
+        let result = template;
+        Object.entries(variables).forEach(([key, value]) => {
+            const regex = new RegExp(`{{${key}}}`, 'g');
+            result = result.replace(regex, value);
         });
+        return result;
     }
-    generateRowToModelMapping(modelConfig) {
-        // Sort fields to match the constructor parameter order
-        const sortedFields = this.sortFieldsByRequired(modelConfig.fields);
-        const mappings = sortedFields.map(field => {
-            if (field.name === 'createdAt') {
-                return '      row.created_at';
+    generateRowFields(fields, childInfo) {
+        const result = [];
+        const ownerOrParentField = childInfo ? childInfo.parentIdField : 'ownerId';
+        result.push(`  ${ownerOrParentField}: number;`);
+        fields.forEach(([fieldName, fieldConfig]) => {
+            const tsType = this.mapTypeToRowType(fieldConfig.type);
+            const isOptional = !fieldConfig.required;
+            result.push(`  ${fieldName}${isOptional ? '?' : ''}: ${tsType};`);
+        });
+        return result.join('\n');
+    }
+    generateFieldNamesStr(fields, childInfo) {
+        const fieldNames = ['id'];
+        fieldNames.push(childInfo ? childInfo.parentIdField : 'ownerId');
+        fieldNames.push(...fields.map(([name]) => name));
+        return fieldNames.map(f => `\\\`${f}\\\``).join(', ');
+    }
+    generateRowToModelMapping(fields, childInfo) {
+        const result = [];
+        const ownerOrParentField = childInfo ? childInfo.parentIdField : 'ownerId';
+        result.push(`      row.${ownerOrParentField}`);
+        fields.forEach(([fieldName, fieldConfig]) => {
+            const fieldType = fieldConfig.type;
+            // Handle datetime/date conversion
+            if (fieldType === 'datetime' || fieldType === 'date') {
+                result.push(this.generateDatetimeConversion(fieldName, 'toDate'));
+                return;
             }
-            // For relationship fields, we pass null - will be loaded separately
-            if (this.isRelationshipField(field)) {
-                return '      null as any'; // Placeholder, loaded via loadRelationships
+            // Handle boolean conversion
+            if (fieldType === 'boolean') {
+                result.push(`      Boolean(row.${fieldName})`);
+                return;
+            }
+            // Handle value object conversion - deserialize from JSON
+            if (this.isValueObjectType(fieldType)) {
+                const voName = this.getValueObjectName(fieldType);
+                const voConfig = this.getValueObjectConfig(fieldType);
+                if (voConfig) {
+                    result.push(this.generateValueObjectDeserialization(fieldName, voName, voConfig));
+                }
+                else {
+                    result.push(`      row.${fieldName} ? new ${voName}(...Object.values(JSON.parse(row.${fieldName}))) : undefined`);
+                }
+                return;
             }
-            return `      row.${field.name}`;
+            result.push(`      row.${fieldName}`);
         });
-        return mappings.join(',\n');
+        return result.join(',\n');
     }
-    generateModelToRowMapping(modelConfig) {
-        const mappings = modelConfig.fields.map(field => {
-            if (field.name === 'createdAt') {
-                return '      created_at: model.createdAt';
+    generateInsertDataMapping(fields, childInfo) {
+        const result = [];
+        const ownerOrParentField = childInfo ? childInfo.parentIdField : 'ownerId';
+        result.push(`      ${ownerOrParentField}: entity.${ownerOrParentField}`);
+        fields.forEach(([fieldName, fieldConfig]) => {
+            const fieldType = fieldConfig.type;
+            // Handle datetime/date - convert Date to MySQL DATETIME format
+            if (fieldType === 'datetime' || fieldType === 'date') {
+                result.push(this.generateDatetimeConversion(fieldName, 'toMySQL'));
+                return;
             }
-            // 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`;
+            // Handle value object - serialize to JSON
+            if (this.isValueObjectType(fieldType)) {
+                const voConfig = this.getValueObjectConfig(fieldType);
+                if (voConfig) {
+                    result.push(this.generateValueObjectSerialization(fieldName, this.getValueObjectName(fieldType), voConfig));
+                }
+                else {
+                    result.push(`      ${fieldName}: entity.${fieldName} ? JSON.stringify(entity.${fieldName}) : undefined`);
+                }
+                return;
             }
-            return `      ${field.name}: model.${field.name}`;
+            result.push(`      ${fieldName}: entity.${fieldName}`);
         });
-        return mappings.join(',\n');
+        return result.join(',\n');
     }
-    replaceTemplateVars(template, variables) {
-        let result = template;
-        Object.entries(variables).forEach(([key, value]) => {
-            const regex = new RegExp(`{{${key}}}`, 'g');
-            result = result.replace(regex, value);
-        });
-        return result;
+    generateUpdateDataMapping(fields) {
+        return fields
+            .map(([fieldName, fieldConfig]) => {
+            const fieldType = fieldConfig.type;
+            if (fieldType === 'datetime' || fieldType === 'date') {
+                return this.generateDatetimeConversion(fieldName, 'toMySQL');
+            }
+            if (this.isValueObjectType(fieldType)) {
+                const voConfig = this.getValueObjectConfig(fieldType);
+                if (voConfig) {
+                    return this.generateValueObjectSerialization(fieldName, this.getValueObjectName(fieldType), voConfig);
+                }
+                return `      ${fieldName}: entity.${fieldName} ? JSON.stringify(entity.${fieldName}) : undefined`;
+            }
+            return `      ${fieldName}: entity.${fieldName}`;
+        })
+            .join(',\n');
     }
-    generateStoreInterface() {
-        return storeTemplates_1.fileTemplates.storeInterface;
+    generateUpdateFieldsArray(fields) {
+        return JSON.stringify(fields.map(([name]) => name));
     }
-    generateRelationshipMethods(modelConfig) {
-        const relationshipFields = modelConfig.fields.filter(f => this.isRelationshipField(f));
-        if (relationshipFields.length === 0) {
+    generateValueObjectImports(fields) {
+        const imports = [];
+        fields.forEach(([, fieldConfig]) => {
+            if (this.isValueObjectType(fieldConfig.type)) {
+                const voName = this.getValueObjectName(fieldConfig.type);
+                const voConfig = this.getValueObjectConfig(fieldConfig.type);
+                // Import the class
+                const importItems = [voName];
+                // Also import the type if it's an enum
+                if (voConfig) {
+                    const enumTypeName = this.getValueObjectFieldTypeName(voName, voConfig);
+                    if (enumTypeName) {
+                        importItems.push(enumTypeName);
+                    }
+                }
+                imports.push(`import { ${importItems.join(', ')} } from '../../domain/valueObjects/${voName}';`);
+            }
+        });
+        // Dedupe imports
+        const uniqueImports = [...new Set(imports)];
+        if (uniqueImports.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 '\n' + uniqueImports.join('\n');
+    }
+    generateGetByParentIdMethod(modelName, fields, childInfo) {
+        if (!childInfo)
+            return '';
+        const fieldList = ['id', childInfo.parentIdField, ...fields.map(([name]) => name)].map(f => '\\`' + f + '\\`').join(', ');
+        const parentIdField = childInfo.parentIdField;
+        return `
+
+  async getByParentId(parentId: number): Promise<${modelName}[]> {
+    const result = await this.db.query(
+      \`SELECT ${fieldList} FROM \\\`\${this.tableName}\\\` WHERE \\\`${parentIdField}\\\` = :parentId AND deleted_at IS NULL\`,
+      { parentId }
+    );
+
+    if (result.success && result.data) {
+      return result.data.map((row: ${modelName}Row) => this.rowToModel(row));
     }
-  }`);
-        return methods.join('\n');
+    return [];
+  }`;
     }
-    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(', ');
+    generateGetResourceOwnerMethod(childInfo) {
+        if (childInfo) {
+            const parentTable = childInfo.parentTableName;
+            const parentIdField = childInfo.parentIdField;
+            return `
+
+  /**
+   * Get the owner ID of a resource by its ID (via parent entity).
+   * Used for pre-mutation authorization checks.
+   */
+  async getResourceOwner(id: number): Promise<number | null> {
+    const result = await this.db.query(
+      \`SELECT p.ownerId FROM \\\`\${this.tableName}\\\` c INNER JOIN \\\`${parentTable}\\\` p ON p.id = c.\\\`${parentIdField}\\\` WHERE c.id = :id AND c.deleted_at IS NULL\`,
+      { id }
+    );
+
+    if (result.success && result.data && result.data.length > 0) {
+      return result.data[0].ownerId as number;
     }
-    generateRelationshipImports(modelConfig) {
-        const relationshipFields = modelConfig.fields.filter(f => this.isRelationshipField(f));
-        if (relationshipFields.length === 0) {
-            return '';
+    return null;
+  }`;
         }
-        const imports = relationshipFields.map(field => {
-            const relatedModel = field.type;
-            return `import { ${relatedModel}Store } from './${relatedModel}Store';`;
-        });
-        return '\n' + imports.join('\n');
+        return `
+
+  /**
+   * Get the owner ID of a resource by its ID.
+   * Used for pre-mutation authorization checks.
+   */
+  async getResourceOwner(id: number): Promise<number | null> {
+    const result = await this.db.query(
+      \`SELECT ownerId FROM \\\`\${this.tableName}\\\` WHERE id = :id AND deleted_at IS NULL\`,
+      { id }
+    );
+
+    if (result.success && result.data && result.data.length > 0) {
+      return result.data[0].ownerId as number;
+    }
+    return null;
+  }`;
     }
-    generateStore(modelConfig) {
-        const entityName = modelConfig.name;
-        const tableName = entityName.toLowerCase() + 's';
+    generateStore(modelName, aggregateConfig, childInfo) {
+        const tableName = modelName.toLowerCase();
+        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 variables = {
-            ENTITY_NAME: entityName,
+            ENTITY_NAME: modelName,
             TABLE_NAME: tableName,
-            ROW_FIELDS: this.generateRowFields(modelConfig),
-            FILTERABLE_FIELDS: this.generateFilterableFields(modelConfig),
-            FILTERABLE_FIELDS_ARRAY: this.generateFilterableFieldsArray(modelConfig),
-            UPDATABLE_FIELDS_ARRAY: this.generateUpdatableFieldsArray(modelConfig),
-            ROW_TO_MODEL_MAPPING: this.generateRowToModelMapping(modelConfig),
-            MODEL_TO_ROW_MAPPING: this.generateModelToRowMapping(modelConfig)
+            ROW_FIELDS: this.generateRowFields(fields, childInfo),
+            FIELD_NAMES: this.generateFieldNamesStr(fields, childInfo),
+            ROW_TO_MODEL_MAPPING: this.generateRowToModelMapping(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),
+            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 conversionMethods = this.replaceTemplateVars(storeTemplates_1.storeTemplates.conversionMethods, variables);
-        // 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,
+        const storeClass = this.replaceTemplateVars(storeTemplates_1.storeTemplates.storeClass, variables);
+        return this.replaceTemplateVars(storeTemplates_1.storeFileTemplate, {
+            ENTITY_NAME: modelName,
             ROW_INTERFACE: rowInterface,
-            STORE_CLASS: storeClass
-        }) + relationshipImports;
+            STORE_CLASS: storeClass,
+            VALUE_OBJECT_IMPORTS: variables.VALUE_OBJECT_IMPORTS
+        });
     }
-    generateStores(models) {
+    generateFromConfig(config) {
         const result = {};
-        models.forEach(model => {
-            result[model.name] = this.generateStore(model);
-        });
+        // First, collect all value object names and configs
+        this.availableValueObjects.clear();
+        if (config.domain.valueObjects) {
+            Object.entries(config.domain.valueObjects).forEach(([name, voConfig]) => {
+                this.availableValueObjects.set(name, voConfig);
+            });
+        }
+        // Generate a store for each aggregate
+        const childEntityMap = (0, childEntityUtils_1.buildChildEntityMap)(config);
+        if (config.domain.aggregates) {
+            Object.entries(config.domain.aggregates).forEach(([modelName, aggregateConfig]) => {
+                const childInfo = childEntityMap.get(modelName);
+                result[modelName] = this.generateStore(modelName, aggregateConfig, childInfo);
+            });
+        }
         return result;
     }
     generateFromYamlFile(yamlFilePath) {
         const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
         const config = (0, yaml_1.parse)(yamlContent);
-        const result = {};
-        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);
-                }
-            });
-        }
-        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);
-            }
+        if (!(0, configTypes_1.isValidModuleConfig)(config)) {
+            throw new Error('Configuration does not match new module format. Expected domain.aggregates structure.');
         }
-        return result;
+        return this.generateFromConfig(config);
     }
-    async generateAndSaveFiles(yamlFilePath = constants_1.COMMON_FILES.APP_YAML, outputDir = 'infrastructure', opts) {
-        const stores = this.generateFromYamlFile(yamlFilePath);
-        const storesDir = path.join(outputDir, 'stores');
-        const interfacesDir = path.join(outputDir, 'interfaces');
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
+        const storesByModel = this.generateFromYamlFile(yamlFilePath);
+        const storesDir = path.join(moduleDir, 'infrastructure', 'stores');
         fs.mkdirSync(storesDir, { recursive: true });
-        fs.mkdirSync(interfacesDir, { recursive: true });
-        const storeInterface = this.generateStoreInterface();
-        const interfaceFilePath = path.join(interfacesDir, constants_1.COMMON_FILES.STORE_INTERFACE);
-        await (0, generationRegistry_1.writeGeneratedFile)(interfaceFilePath, storeInterface, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
-        for (const [entityName, storeCode] of Object.entries(stores)) {
-            const fileName = `${entityName}Store.ts`;
-            const filePath = path.join(storesDir, fileName);
+        for (const [modelName, code] of Object.entries(storesByModel)) {
+            const filePath = path.join(storesDir, `${modelName}Store.ts`);
             // eslint-disable-next-line no-await-in-loop
-            await (0, generationRegistry_1.writeGeneratedFile)(filePath, storeCode, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
+            await (0, generationRegistry_1.writeGeneratedFile)(filePath, code, { force: !!(opts === null || opts === void 0 ? void 0 : opts.force), skipOnConflict: !!(opts === null || opts === void 0 ? void 0 : opts.skipOnConflict) });
         }
         // eslint-disable-next-line no-console
-        console.log('\n' + colors_1.colors.green('All store files generated successfully!') + '\n');
+        console.log('\n' + colors_1.colors.green('Store files generated successfully!') + '\n');
     }
 }
 exports.StoreGenerator = StoreGenerator;

package/dist/generators/storeGeneratorV2.d.ts

@@ -0,0 +1,31 @@
+interface FieldConfig {
+    name: string;
+    type: string;
+    required?: boolean;
+    unique?: boolean;
+    auto?: boolean;
+}
+interface ModelConfig {
+    name: string;
+    fields: FieldConfig[];
+}
+export declare class StoreGeneratorV2 {
+    private typeMapping;
+    private mapType;
+    private generateRowFields;
+    private generateFilterableFields;
+    private generateFilterableFieldsArray;
+    private generateUpdatableFieldsArray;
+    private generateRowToModelMapping;
+    private generateModelToRowMapping;
+    private replaceTemplateVars;
+    generateStoreInterface(): string;
+    generateStore(modelConfig: ModelConfig): string;
+    generateStores(models: ModelConfig[]): Record<string, string>;
+    generateFromYamlFile(yamlFilePath: string): Record<string, string>;
+    generateAndSaveFiles(yamlFilePath?: string, outputDir?: string, opts?: {
+        force?: boolean;
+        skipOnConflict?: boolean;
+    }): Promise<void>;
+}
+export {};