@currentjs/gen 0.5.3 → 0.5.5

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.5.5] - 2026-04-07
+
+- data access layer generation fixes and improvements
+
+## [0.5.4] - 2026-04-07
+
+- Array and union value objects
+
 ## [0.5.3] - 2026-04-07
 
 - expand autowiring (DI) for providers

package/dist/commands/migrateCommit.js

@@ -42,11 +42,12 @@ const cliUtils_1 = require("../utils/cliUtils");
 const commandUtils_1 = require("../utils/commandUtils");
 const configTypes_1 = require("../types/configTypes");
 const migrationUtils_1 = require("../utils/migrationUtils");
-function collectAggregatesFromModules(appYamlPath) {
+function collectSchemaFromModules(appYamlPath) {
     const appConfig = (0, commandUtils_1.loadAppConfig)(appYamlPath);
     const moduleEntries = (0, commandUtils_1.getModuleEntries)(appConfig);
     const projectRoot = path.dirname(appYamlPath);
     const allAggregates = {};
+    const allValueObjects = new Set();
     const sources = [];
     for (const entry of moduleEntries) {
         const moduleYamlPath = path.isAbsolute(entry.path)
@@ -67,13 +68,18 @@ function collectAggregatesFromModules(appYamlPath) {
         const aggregates = moduleConfig.domain.aggregates;
         const count = Object.keys(aggregates).length;
         Object.assign(allAggregates, aggregates);
+        if (moduleConfig.domain.valueObjects) {
+            for (const voName of Object.keys(moduleConfig.domain.valueObjects)) {
+                allValueObjects.add(voName);
+            }
+        }
         sources.push(`${entry.name} (${count} aggregate(s))`);
     }
     if (sources.length > 0) {
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.gray(`   Sources: ${sources.join(', ')}`));
     }
-    return allAggregates;
+    return { aggregates: allAggregates, valueObjects: allValueObjects };
 }
 function handleMigrateCommit(yamlPath) {
     try {
@@ -94,7 +100,7 @@ function handleMigrateCommit(yamlPath) {
         }
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.cyan('\n📋 Collecting aggregates from all modules...'));
-        const currentAggregates = collectAggregatesFromModules(resolvedYamlPath);
+        const { aggregates: currentAggregates, valueObjects: currentValueObjects } = collectSchemaFromModules(resolvedYamlPath);
         if (Object.keys(currentAggregates).length === 0) {
             // eslint-disable-next-line no-console
             console.log(colors_1.colors.yellow('⚠️  No aggregates found in module configuration.'));
@@ -113,7 +119,7 @@ function handleMigrateCommit(yamlPath) {
         }
         // eslint-disable-next-line no-console
         console.log(colors_1.colors.cyan('\n🔍 Comparing schemas...'));
-        const sqlStatements = (0, migrationUtils_1.compareSchemas)(oldState, currentAggregates);
+        const sqlStatements = (0, migrationUtils_1.compareSchemas)(oldState, currentAggregates, currentValueObjects);
         if (sqlStatements.length === 0 || sqlStatements.every(s => s.trim() === '' || s.startsWith('--'))) {
             // eslint-disable-next-line no-console
             console.log(colors_1.colors.yellow('⚠️  No changes detected. Schema is up to date.'));
@@ -132,7 +138,7 @@ function handleMigrateCommit(yamlPath) {
         const newState = {
             aggregates: currentAggregates,
             version: timestamp,
-            timestamp: new Date().toISOString()
+            timestamp: new Date().toISOString(),
         };
         (0, migrationUtils_1.saveSchemaState)(stateFilePath, newState);
         // eslint-disable-next-line no-console

package/dist/generators/domainLayerGenerator.js

@@ -137,14 +137,13 @@ class DomainLayerGenerator {
             .filter(entityName => entityName !== name && allAggregates[entityName])
             .map(entityName => `import { ${entityName} } from './${entityName}';`)
             .join('\n');
-        // Generate imports for value objects used in fields
-        const valueObjectImports = fields
-            .filter(([, fieldConfig]) => this.availableValueObjects.has((0, typeUtils_1.capitalize)(fieldConfig.type)))
-            .map(([, fieldConfig]) => {
-            const voName = (0, typeUtils_1.capitalize)(fieldConfig.type);
-            return `import { ${voName} } from '../valueObjects/${voName}';`;
-        })
-            .filter((imp, idx, arr) => arr.indexOf(imp) === idx) // dedupe
+        // Generate imports for value objects used in fields (including compound types like Foo[] and Foo | Bar)
+        const referencedVoNames = new Set();
+        fields.forEach(([, fieldConfig]) => {
+            (0, typeUtils_1.getReferencedValueObjects)(fieldConfig.type, this.availableValueObjects).forEach(name => referencedVoNames.add(name));
+        });
+        const valueObjectImports = [...referencedVoNames]
+            .map(voName => `import { ${voName} } from '../valueObjects/${voName}';`)
             .join('\n');
         // Generate imports for aggregate references in fields (e.g. idea: { type: Idea })
         const aggregateRefImports = fields

package/dist/generators/dtoGenerator.js

@@ -51,8 +51,7 @@ class DtoGenerator {
         return (0, typeUtils_1.mapType)(yamlType, this.availableAggregates, this.availableValueObjects);
     }
     isValueObjectType(yamlType) {
-        const capitalizedType = (0, typeUtils_1.capitalize)(yamlType);
-        return this.availableValueObjects.has(capitalizedType);
+        return (0, typeUtils_1.isValueObjectFieldType)(yamlType, this.availableValueObjects);
     }
     getValidationCode(fieldName, fieldType, isRequired) {
         const checks = [];
@@ -431,11 +430,11 @@ ${mappingsStr}
             if (outputConfig.pick && outputConfig.pick.length > 0) {
                 fieldsToCheck = fieldsToCheck.filter(([fieldName]) => outputConfig.pick.includes(fieldName));
             }
-            // Check each field for value object types
+            // Check each field for value object types (including compound types like Foo[] and Foo | Bar)
             fieldsToCheck.forEach(([, fieldConfig]) => {
-                if (this.isValueObjectType(fieldConfig.type)) {
-                    valueObjects.add((0, typeUtils_1.capitalize)(fieldConfig.type));
-                }
+                (0, typeUtils_1.getReferencedValueObjects)(fieldConfig.type, this.availableValueObjects).forEach(voName => {
+                    valueObjects.add(voName);
+                });
             });
         }
         // Check include for child entities

package/dist/generators/storeGenerator.d.ts

@@ -4,6 +4,8 @@ export declare class StoreGenerator {
     private availableAggregates;
     private isAggregateField;
     private isValueObjectType;
+    private isArrayVoType;
+    private isUnionVoType;
     private getValueObjectName;
     private getValueObjectConfig;
     /**
@@ -21,8 +23,20 @@ export declare class StoreGenerator {
     private mapTypeToRowType;
     /** Single line for serializing a value object field to DB (insert/update). */
     private generateValueObjectSerialization;
+    /** Serialization for an array-of-VOs field. */
+    private generateArrayVoSerialization;
+    /** Serialization for a union-of-VOs field. Uses _type discriminator. */
+    private generateUnionVoSerialization;
     /** Single line for deserializing a value object from row (rowToModel). */
     private generateValueObjectDeserialization;
+    /** Deserialization for an array-of-VOs field. */
+    private generateArrayVoDeserialization;
+    /** Deserialization for a union-of-VOs field. Uses _type discriminator. */
+    private generateUnionVoDeserialization;
+    /** Serialization for an array-of-union-VOs field. Each element tagged with _type discriminator. */
+    private generateArrayUnionVoSerialization;
+    /** Deserialization for an array-of-union-VOs field. Each element reconstructed via _type. */
+    private generateArrayUnionVoDeserialization;
     /** Single line for datetime conversion: toDate (row->model) or toMySQL (entity->row). */
     private generateDatetimeConversion;
     private replaceTemplateVars;

package/dist/generators/storeGenerator.js

@@ -52,8 +52,16 @@ class StoreGenerator {
         return (0, typeUtils_1.isAggregateReference)(fieldConfig.type, this.availableAggregates);
     }
     isValueObjectType(fieldType) {
-        const capitalizedType = (0, typeUtils_1.capitalize)(fieldType);
-        return this.availableValueObjects.has(capitalizedType);
+        const { baseTypes } = (0, typeUtils_1.parseFieldType)(fieldType);
+        return baseTypes.some(bt => this.availableValueObjects.has((0, typeUtils_1.capitalize)(bt)));
+    }
+    isArrayVoType(fieldType) {
+        const parsed = (0, typeUtils_1.parseFieldType)(fieldType);
+        return parsed.isArray && parsed.baseTypes.some(bt => this.availableValueObjects.has((0, typeUtils_1.capitalize)(bt)));
+    }
+    isUnionVoType(fieldType) {
+        const parsed = (0, typeUtils_1.parseFieldType)(fieldType);
+        return parsed.isUnion && parsed.baseTypes.some(bt => this.availableValueObjects.has((0, typeUtils_1.capitalize)(bt)));
     }
     getValueObjectName(fieldType) {
         return (0, typeUtils_1.capitalize)(fieldType);
@@ -105,12 +113,24 @@ class StoreGenerator {
         }
         return `      ${fieldName}: entity.${fieldName} ? JSON.stringify(entity.${fieldName}) : undefined`;
     }
+    /** Serialization for an array-of-VOs field. */
+    generateArrayVoSerialization(fieldName) {
+        return `      ${fieldName}: entity.${fieldName} ? JSON.stringify(entity.${fieldName}) : undefined`;
+    }
+    /** Serialization for a union-of-VOs field. Uses _type discriminator. */
+    generateUnionVoSerialization(fieldName, unionVoNames) {
+        const checks = unionVoNames
+            .map(voName => `entity.${fieldName} instanceof ${voName} ? '${voName}'`)
+            .join(' : ');
+        const discriminator = `${checks} : 'unknown'`;
+        return `      ${fieldName}: entity.${fieldName} ? JSON.stringify({ _type: ${discriminator}, ...entity.${fieldName} }) : undefined`;
+    }
     /** 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`;
+            return `      row.${fieldName} ? (() => { const parsed = this.ensureParsed(row.${fieldName}); return new ${voName}(${voArgs}); })() : undefined`;
         }
         if (voFields.length === 1) {
             const singleFieldType = voConfig.fields[voFields[0]];
@@ -121,7 +141,47 @@ class StoreGenerator {
             }
             return `      row.${fieldName} ? new ${voName}(row.${fieldName}) : undefined`;
         }
-        return `      row.${fieldName} ? new ${voName}(...Object.values(JSON.parse(row.${fieldName}))) : undefined`;
+        return `      row.${fieldName} ? new ${voName}(...Object.values(this.ensureParsed(row.${fieldName}))) : undefined`;
+    }
+    /** Deserialization for an array-of-VOs field. */
+    generateArrayVoDeserialization(fieldName, voName, voConfig) {
+        const voFields = Object.keys(voConfig.fields);
+        const itemArgs = voFields.length > 0
+            ? voFields.map(f => `item.${f}`).join(', ')
+            : '...Object.values(item)';
+        return `      row.${fieldName} ? (this.ensureParsed(row.${fieldName}) as any[]).map((item: any) => new ${voName}(${itemArgs})) : []`;
+    }
+    /** Deserialization for a union-of-VOs field. Uses _type discriminator. */
+    generateUnionVoDeserialization(fieldName, unionVoNames, unionVoConfigs) {
+        const cases = unionVoNames.map(voName => {
+            const cfg = unionVoConfigs[voName];
+            const voFields = cfg ? Object.keys(cfg.fields) : [];
+            const args = voFields.length > 0
+                ? voFields.map(f => `parsed.${f}`).join(', ')
+                : '...Object.values(parsed)';
+            return `if (parsed._type === '${voName}') return new ${voName}(${args});`;
+        }).join(' ');
+        return `      row.${fieldName} ? (() => { const parsed = this.ensureParsed(row.${fieldName}); ${cases} return undefined; })() : undefined`;
+    }
+    /** Serialization for an array-of-union-VOs field. Each element tagged with _type discriminator. */
+    generateArrayUnionVoSerialization(fieldName, unionVoNames) {
+        const checks = unionVoNames
+            .map(voName => `item instanceof ${voName} ? '${voName}'`)
+            .join(' : ');
+        const discriminator = `${checks} : 'unknown'`;
+        return `      ${fieldName}: entity.${fieldName} ? JSON.stringify(entity.${fieldName}.map((item: any) => ({ _type: ${discriminator}, ...item }))) : undefined`;
+    }
+    /** Deserialization for an array-of-union-VOs field. Each element reconstructed via _type. */
+    generateArrayUnionVoDeserialization(fieldName, unionVoNames, unionVoConfigs) {
+        const cases = unionVoNames.map(voName => {
+            const cfg = unionVoConfigs[voName];
+            const voFields = cfg ? Object.keys(cfg.fields) : [];
+            const args = voFields.length > 0
+                ? voFields.map(f => `item.${f}`).join(', ')
+                : '...Object.values(item)';
+            return `if (item._type === '${voName}') return new ${voName}(${args});`;
+        }).join(' ');
+        return `      row.${fieldName} ? (this.ensureParsed(row.${fieldName}) as any[]).map((item: any) => { ${cases} return undefined; }) : []`;
     }
     /** Single line for datetime conversion: toDate (row->model) or toMySQL (entity->row). */
     generateDatetimeConversion(fieldName, direction) {
@@ -144,7 +204,7 @@ class StoreGenerator {
         result.push(`  ${ownerOrParentField}: number;`);
         fields.forEach(([fieldName, fieldConfig]) => {
             if (this.isAggregateField(fieldConfig)) {
-                result.push(`  ${fieldName}_id?: number;`);
+                result.push(`  ${fieldName}Id?: number;`);
                 return;
             }
             const tsType = this.mapTypeToRowType(fieldConfig.type);
@@ -156,7 +216,7 @@ class StoreGenerator {
     generateFieldNamesStr(fields, childInfo) {
         const fieldNames = ['id'];
         fieldNames.push(childInfo ? childInfo.parentIdField : 'ownerId');
-        fieldNames.push(...fields.map(([name, config]) => this.isAggregateField(config) ? `${name}_id` : name));
+        fieldNames.push(...fields.map(([name, config]) => this.isAggregateField(config) ? `${name}Id` : name));
         return fieldNames.map(f => `\\\`${f}\\\``).join(', ');
     }
     generateRowToModelMapping(modelName, fields, childInfo) {
@@ -173,7 +233,7 @@ class StoreGenerator {
             }
             // 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`);
+                result.push(`      row.${fieldName}Id != null ? ({ id: row.${fieldName}Id } as unknown as ${fieldType}) : undefined`);
                 return;
             }
             // Handle datetime/date conversion
@@ -186,15 +246,44 @@ class StoreGenerator {
                 result.push(`      Boolean(row.${fieldName})`);
                 return;
             }
-            // Handle value object conversion - deserialize from JSON
+            // Handle value object conversion - deserialize from JSON (simple, array, union, or array-of-union)
             if (this.isValueObjectType(fieldType)) {
+                const parsed = (0, typeUtils_1.parseFieldType)(fieldType);
+                if (parsed.isArray && parsed.isUnion) {
+                    const unionVoNames = parsed.baseTypes.map(bt => (0, typeUtils_1.capitalize)(bt)).filter(name => this.availableValueObjects.has(name));
+                    const unionVoConfigs = {};
+                    unionVoNames.forEach(name => {
+                        const cfg = this.availableValueObjects.get(name);
+                        if (cfg)
+                            unionVoConfigs[name] = cfg;
+                    });
+                    result.push(this.generateArrayUnionVoDeserialization(fieldName, unionVoNames, unionVoConfigs));
+                    return;
+                }
+                if (parsed.isArray) {
+                    const voName = (0, typeUtils_1.capitalize)(parsed.baseTypes[0]);
+                    const voConfig = this.availableValueObjects.get(voName);
+                    result.push(this.generateArrayVoDeserialization(fieldName, voName, voConfig || { fields: {} }));
+                    return;
+                }
+                if (parsed.isUnion) {
+                    const unionVoNames = parsed.baseTypes.map(bt => (0, typeUtils_1.capitalize)(bt)).filter(name => this.availableValueObjects.has(name));
+                    const unionVoConfigs = {};
+                    unionVoNames.forEach(name => {
+                        const cfg = this.availableValueObjects.get(name);
+                        if (cfg)
+                            unionVoConfigs[name] = cfg;
+                    });
+                    result.push(this.generateUnionVoDeserialization(fieldName, unionVoNames, unionVoConfigs));
+                    return;
+                }
                 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`);
+                    result.push(`      row.${fieldName} ? new ${voName}(...Object.values(this.ensureParsed(row.${fieldName}))) : undefined`);
                 }
                 return;
             }
@@ -210,7 +299,7 @@ class StoreGenerator {
             const fieldType = fieldConfig.type;
             // Handle aggregate reference - extract FK id
             if (this.isAggregateField(fieldConfig)) {
-                result.push(`      ${fieldName}_id: entity.${fieldName}?.id`);
+                result.push(`      ${fieldName}Id: entity.${fieldName}?.id`);
                 return;
             }
             // Handle datetime/date - convert Date to MySQL DATETIME format
@@ -218,8 +307,23 @@ class StoreGenerator {
                 result.push(this.generateDatetimeConversion(fieldName, 'toMySQL'));
                 return;
             }
-            // Handle value object - serialize to JSON
+            // Handle value object - serialize to JSON (simple, array, union, or array-of-union)
             if (this.isValueObjectType(fieldType)) {
+                const parsed = (0, typeUtils_1.parseFieldType)(fieldType);
+                if (parsed.isArray && parsed.isUnion) {
+                    const unionVoNames = parsed.baseTypes.map(bt => (0, typeUtils_1.capitalize)(bt)).filter(name => this.availableValueObjects.has(name));
+                    result.push(this.generateArrayUnionVoSerialization(fieldName, unionVoNames));
+                    return;
+                }
+                if (parsed.isArray) {
+                    result.push(this.generateArrayVoSerialization(fieldName));
+                    return;
+                }
+                if (parsed.isUnion) {
+                    const unionVoNames = parsed.baseTypes.map(bt => (0, typeUtils_1.capitalize)(bt)).filter(name => this.availableValueObjects.has(name));
+                    result.push(this.generateUnionVoSerialization(fieldName, unionVoNames));
+                    return;
+                }
                 const voConfig = this.getValueObjectConfig(fieldType);
                 if (voConfig) {
                     result.push(this.generateValueObjectSerialization(fieldName, this.getValueObjectName(fieldType), voConfig));
@@ -238,12 +342,24 @@ class StoreGenerator {
             .map(([fieldName, fieldConfig]) => {
             const fieldType = fieldConfig.type;
             if (this.isAggregateField(fieldConfig)) {
-                return `      ${fieldName}_id: entity.${fieldName}?.id`;
+                return `      ${fieldName}Id: entity.${fieldName}?.id`;
             }
             if (fieldType === 'datetime' || fieldType === 'date') {
                 return this.generateDatetimeConversion(fieldName, 'toMySQL');
             }
             if (this.isValueObjectType(fieldType)) {
+                const parsed = (0, typeUtils_1.parseFieldType)(fieldType);
+                if (parsed.isArray && parsed.isUnion) {
+                    const unionVoNames = parsed.baseTypes.map(bt => (0, typeUtils_1.capitalize)(bt)).filter(name => this.availableValueObjects.has(name));
+                    return this.generateArrayUnionVoSerialization(fieldName, unionVoNames);
+                }
+                if (parsed.isArray) {
+                    return this.generateArrayVoSerialization(fieldName);
+                }
+                if (parsed.isUnion) {
+                    const unionVoNames = parsed.baseTypes.map(bt => (0, typeUtils_1.capitalize)(bt)).filter(name => this.availableValueObjects.has(name));
+                    return this.generateUnionVoSerialization(fieldName, unionVoNames);
+                }
                 const voConfig = this.getValueObjectConfig(fieldType);
                 if (voConfig) {
                     return this.generateValueObjectSerialization(fieldName, this.getValueObjectName(fieldType), voConfig);
@@ -255,31 +371,30 @@ class StoreGenerator {
             .join(',\n');
     }
     generateUpdateFieldsArray(fields) {
-        return JSON.stringify(fields.map(([name, config]) => this.isAggregateField(config) ? `${name}_id` : name));
+        return JSON.stringify(fields.map(([name, config]) => this.isAggregateField(config) ? `${name}Id` : name));
     }
     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
+            if (!this.isValueObjectType(fieldConfig.type))
+                return;
+            // Collect all VO names referenced in this field type (handles Foo[], Foo | Bar)
+            const referencedVoNames = (0, typeUtils_1.getReferencedValueObjects)(fieldConfig.type, this.availableValueObjects);
+            referencedVoNames.forEach(voName => {
+                const voConfig = this.availableValueObjects.get(voName);
                 const importItems = [voName];
-                // Also import the type if it's an enum
-                if (voConfig) {
+                // Also import enum type alias if present (only for simple single-VO fields)
+                if (voConfig && !(0, typeUtils_1.parseFieldType)(fieldConfig.type).isArray && !(0, typeUtils_1.parseFieldType)(fieldConfig.type).isUnion) {
                     const enumTypeName = this.getValueObjectFieldTypeName(voName, voConfig);
-                    if (enumTypeName) {
+                    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) {
+        if (uniqueImports.length === 0)
             return '';
-        }
         return '\n' + uniqueImports.join('\n');
     }
     generateAggregateRefImports(modelName, fields) {
@@ -308,7 +423,7 @@ class StoreGenerator {
     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\`,
+      \`SELECT ${fieldNamesStr} FROM \\\`\${this.tableName}\\\` WHERE deletedAt IS NULL${ownerFilterRef} LIMIT :limit OFFSET :offset\`,
       params
     );
 
@@ -320,7 +435,7 @@ class StoreGenerator {
         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}\`,
+      \`SELECT ${fieldNamesStr} FROM \\\`\${this.tableName}\\\` WHERE deletedAt IS NULL${ownerFilterRef}\`,
       params
     );
 
@@ -332,7 +447,7 @@ class StoreGenerator {
         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}\`,
+      \`SELECT COUNT(*) as count FROM \\\`\${this.tableName}\\\` WHERE deletedAt IS NULL${ownerFilterRef}\`,
       params
     );
 
@@ -346,13 +461,13 @@ class StoreGenerator {
     generateGetByParentIdMethod(modelName, fields, childInfo) {
         if (!childInfo)
             return '';
-        const fieldList = ['id', childInfo.parentIdField, ...fields.map(([name, config]) => this.isAggregateField(config) ? `${name}_id` : 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 `
 
   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\`,
+      \`SELECT ${fieldList} FROM \\\`\${this.tableName}\\\` WHERE \\\`${parentIdField}\\\` = :parentId AND deletedAt IS NULL\`,
       { parentId }
     );
 
@@ -374,7 +489,7 @@ class StoreGenerator {
    */
   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\`,
+      \`SELECT p.ownerId FROM \\\`\${this.tableName}\\\` c INNER JOIN \\\`${parentTable}\\\` p ON p.id = c.\\\`${parentIdField}\\\` WHERE c.id = :id AND c.deletedAt IS NULL\`,
       { id }
     );
 
@@ -392,7 +507,7 @@ class StoreGenerator {
    */
   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\`,
+      \`SELECT ownerId FROM \\\`\${this.tableName}\\\` WHERE id = :id AND deletedAt IS NULL\`,
       { id }
     );
 

package/dist/generators/templateGenerator.d.ts

@@ -19,6 +19,21 @@ export declare class TemplateGenerator {
     private renderEditTemplate;
     private getInputType;
     private renderValueObjectField;
+    /**
+     * Render an array-of-VOs field as checkboxes.
+     * If the VO has a single enum field: one checkbox per enum value.
+     * If the VO has multiple / non-enum fields: one labeled checkbox group per VO subfield.
+     */
+    private renderArrayVoField;
+    /**
+     * Render a union-of-VOs field as a type selector with sub-fields for each VO type.
+     */
+    private renderUnionVoField;
+    /**
+     * Render an array-of-union-VOs field as a repeatable group where each item
+     * has a type selector and conditionally-shown sub-fields per VO type.
+     */
+    private renderArrayUnionVoField;
     private renderFormField;
     private getEnumValuesMap;
     generateFromConfig(config: ModuleConfig): Record<string, string>;