@currentjs/gen 0.5.3 → 0.5.4

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [0.5.4] - 2026-04-07
+
+- Array and union value objects
+
 ## [0.5.3] - 2026-04-07
 
 - expand autowiring (DI) for providers

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,6 +113,18 @@ 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);
@@ -123,6 +143,46 @@ class StoreGenerator {
         }
         return `      row.${fieldName} ? new ${voName}(...Object.values(JSON.parse(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} ? (JSON.parse(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 = JSON.parse(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} ? (JSON.parse(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) {
         if (direction === 'toDate') {
@@ -186,8 +246,37 @@ 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) {
@@ -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));
@@ -244,6 +348,18 @@ class StoreGenerator {
                 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);
@@ -260,26 +376,25 @@ class StoreGenerator {
     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) {

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>;

package/dist/generators/templateGenerator.js

@@ -69,7 +69,12 @@ class TemplateGenerator {
             .filter(([name]) => name !== 'id')
             .slice(0, 5)
             .map(([name, config]) => {
-            const voConfig = this.valueObjects[(0, typeUtils_1.capitalize)((config.type || 'string'))];
+            const typeStr = (config.type || 'string');
+            const parsed = (0, typeUtils_1.parseFieldType)(typeStr);
+            if (parsed.isArray || parsed.isUnion) {
+                return `      <td>{{ item.${name} }}</td>`;
+            }
+            const voConfig = this.valueObjects[(0, typeUtils_1.capitalize)(typeStr)];
             if (voConfig) {
                 const parts = Object.keys(voConfig.fields)
                     .map(sub => `{{ item.${name}.${sub} }}`)
@@ -136,12 +141,16 @@ ${fieldCells}
         const fieldEntries = Object.entries(child.childFields).filter(([name]) => name !== 'id').slice(0, 5);
         const headers = fieldEntries.map(([name]) => `      <th>${(0, typeUtils_1.capitalize)(name)}</th>`).join('\n');
         const cells = fieldEntries.map(([name, config]) => {
-            const voConfig = this.valueObjects[(0, typeUtils_1.capitalize)(((config === null || config === void 0 ? void 0 : config.type) || 'string'))];
-            if (voConfig) {
-                const parts = Object.keys(voConfig.fields)
-                    .map(sub => `{{ childItem.${name}.${sub} }}`)
-                    .join(' ');
-                return `      <td>${parts}</td>`;
+            const typeStr = ((config === null || config === void 0 ? void 0 : config.type) || 'string');
+            const parsedType = (0, typeUtils_1.parseFieldType)(typeStr);
+            if (!parsedType.isArray && !parsedType.isUnion) {
+                const voConfig = this.valueObjects[(0, typeUtils_1.capitalize)(typeStr)];
+                if (voConfig) {
+                    const parts = Object.keys(voConfig.fields)
+                        .map(sub => `{{ childItem.${name}.${sub} }}`)
+                        .join(' ');
+                    return `      <td>${parts}</td>`;
+                }
             }
             return `      <td>{{ childItem.${name} }}</td>`;
         }).join('\n');
@@ -177,7 +186,15 @@ ${actionLinks}
     renderDetailTemplate(modelName, viewName, fields, basePath, withChildChildren) {
         const fieldRows = fields
             .map(([name, config]) => {
-            const voConfig = this.valueObjects[(0, typeUtils_1.capitalize)((config.type || 'string'))];
+            const typeStr = (config.type || 'string');
+            const parsed = (0, typeUtils_1.parseFieldType)(typeStr);
+            if (parsed.isArray || parsed.isUnion) {
+                return `  <div class="row mb-2">
+    <div class="col-4"><strong>${(0, typeUtils_1.capitalize)(name)}:</strong></div>
+    <div class="col-8">{{ ${name} }}</div>
+  </div>`;
+            }
+            const voConfig = this.valueObjects[(0, typeUtils_1.capitalize)(typeStr)];
             if (voConfig) {
                 const parts = Object.keys(voConfig.fields)
                     .map(sub => `{{ ${name}.${sub} }}`)
@@ -215,6 +232,15 @@ ${fieldRows}
     buildFieldTypesJson(safeFields) {
         return JSON.stringify(safeFields.reduce((acc, [name, config]) => {
             const typeStr = typeof (config === null || config === void 0 ? void 0 : config.type) === 'string' ? config.type : 'string';
+            const parsed = (0, typeUtils_1.parseFieldType)(typeStr);
+            // Array or union of VOs → stored as JSON, emit single "json" entry
+            if (parsed.isArray || parsed.isUnion) {
+                const anyVoReferenced = parsed.baseTypes.some(bt => this.valueObjects[(0, typeUtils_1.capitalize)(bt)]);
+                if (anyVoReferenced) {
+                    acc[name] = 'json';
+                    return acc;
+                }
+            }
             const capitalizedType = (0, typeUtils_1.capitalize)(typeStr);
             const voConfig = this.valueObjects[capitalizedType];
             if (voConfig) {
@@ -319,13 +345,192 @@ ${options}
     <div class="row g-2">
 ${columns}
     </div>
+  </div>`;
+    }
+    /**
+     * 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.
+     */
+    renderArrayVoField(name, label, voName, voConfig, isEdit) {
+        const subFields = Object.entries(voConfig.fields);
+        // Single enum field: render one checkbox per enum value
+        if (subFields.length === 1) {
+            const [subName, subConfig] = subFields[0];
+            if (typeof subConfig === 'object' && 'values' in subConfig) {
+                const uniqueValues = [...new Set(subConfig.values)];
+                const checkboxes = uniqueValues.map(v => {
+                    const checkedExpr = isEdit ? ` {{ (${name} || []).some(function(item){ return item.${subName} === '${v}'; }) ? 'checked' : '' }}` : '';
+                    return `      <div class="form-check form-check-inline">
+        <input type="checkbox" class="form-check-input" name="${name}[]" value="${v}"${checkedExpr}>
+        <label class="form-check-label">${v}</label>
+      </div>`;
+                }).join('\n');
+                return `  <div class="mb-3">
+    <label class="form-label">${label}</label>
+    <div>
+${checkboxes}
+    </div>
+  </div>`;
+            }
+        }
+        // Multi-field VO: render a repeatable entry group with one checkbox-style row per sub-field
+        const subInputs = subFields.map(([subName, subConfig]) => {
+            const subLabel = (0, typeUtils_1.capitalize)(subName);
+            if (typeof subConfig === 'object' && 'values' in subConfig) {
+                const uniqueValues = [...new Set(subConfig.values)];
+                const options = uniqueValues.map(v => `<option value="${v}">${v}</option>`).join('');
+                return `        <div class="col-auto">
+          <label class="form-label">${subLabel}</label>
+          <select class="form-select form-select-sm" name="${name}[0].${subName}"><option value="">--</option>${options}</select>
+        </div>`;
+            }
+            const inputType = this.getInputType(subConfig.type);
+            return `        <div class="col">
+          <label class="form-label">${subLabel}</label>
+          <input type="${inputType}" class="form-control form-control-sm" name="${name}[0].${subName}" placeholder="${subLabel}">
+        </div>`;
+        }).join('\n');
+        return `  <div class="mb-3">
+    <label class="form-label">${label}</label>
+    <div class="border rounded p-2">
+      <div class="row g-2 align-items-end">
+${subInputs}
+      </div>
+      <small class="text-muted">Add multiple ${voName} entries as needed.</small>
+    </div>
+  </div>`;
+    }
+    /**
+     * Render a union-of-VOs field as a type selector with sub-fields for each VO type.
+     */
+    renderUnionVoField(name, label, unionVoNames, isEdit) {
+        const typeOptions = unionVoNames.map(voName => {
+            const sel = isEdit ? ` {{ ${name}._type === '${voName}' ? 'selected' : '' }}` : '';
+            return `      <option value="${voName}"${sel}>${voName}</option>`;
+        }).join('\n');
+        const subFieldGroups = unionVoNames.map(voName => {
+            const voConfig = this.valueObjects[voName];
+            if (!voConfig)
+                return '';
+            const subInputs = Object.entries(voConfig.fields).map(([subName, subConfig]) => {
+                const subLabel = (0, typeUtils_1.capitalize)(subName);
+                const fullName = `${name}.${subName}`;
+                if (typeof subConfig === 'object' && 'values' in subConfig) {
+                    const uniqueValues = [...new Set(subConfig.values)];
+                    const options = uniqueValues.map(v => {
+                        const sel = isEdit ? ` {{ ${name}.${subName} === '${v}' ? 'selected' : '' }}` : '';
+                        return `            <option value="${v}"${sel}>${v}</option>`;
+                    }).join('\n');
+                    return `        <div class="col-auto">
+          <label class="form-label">${subLabel}</label>
+          <select class="form-select" id="${fullName}" name="${fullName}">
+            <option value="">-- ${subLabel} --</option>
+${options}
+          </select>
+        </div>`;
+                }
+                const inputType = this.getInputType(subConfig.type);
+                const value = isEdit ? ` value="{{ ${name}.${subName} || '' }}"` : '';
+                return `        <div class="col">
+          <label class="form-label">${subLabel}</label>
+          <input type="${inputType}" class="form-control" id="${fullName}" name="${fullName}" placeholder="${subLabel}"${value}>
+        </div>`;
+            }).join('\n');
+            return `      <div class="${name}-fields-${voName}">
+        <div class="row g-2">
+${subInputs}
+        </div>
+      </div>`;
+        }).join('\n');
+        return `  <div class="mb-3">
+    <label for="${name}_type" class="form-label">${label} Type</label>
+    <select class="form-select mb-2" id="${name}_type" name="${name}._type">
+      <option value="">-- Select type --</option>
+${typeOptions}
+    </select>
+${subFieldGroups}
+  </div>`;
+    }
+    /**
+     * 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.
+     */
+    renderArrayUnionVoField(name, label, unionVoNames, isEdit) {
+        const typeOptions = unionVoNames.map(voName => {
+            return `          <option value="${voName}">${voName}</option>`;
+        }).join('\n');
+        const subFieldGroups = unionVoNames.map(voName => {
+            const voConfig = this.valueObjects[voName];
+            if (!voConfig)
+                return '';
+            const subInputs = Object.entries(voConfig.fields).map(([subName, subConfig]) => {
+                const subLabel = (0, typeUtils_1.capitalize)(subName);
+                const fullName = `${name}[0].${subName}`;
+                if (typeof subConfig === 'object' && 'values' in subConfig) {
+                    const uniqueValues = [...new Set(subConfig.values)];
+                    const options = uniqueValues.map(v => `<option value="${v}">${v}</option>`).join('');
+                    return `          <div class="col-auto">
+            <label class="form-label">${subLabel}</label>
+            <select class="form-select form-select-sm" name="${fullName}"><option value="">--</option>${options}</select>
+          </div>`;
+                }
+                const inputType = this.getInputType(subConfig.type);
+                return `          <div class="col">
+            <label class="form-label">${subLabel}</label>
+            <input type="${inputType}" class="form-control form-control-sm" name="${fullName}" placeholder="${subLabel}">
+          </div>`;
+            }).join('\n');
+            return `        <div class="${name}-fields-${voName}">
+          <div class="row g-2">
+${subInputs}
+          </div>
+        </div>`;
+        }).join('\n');
+        const editHint = isEdit ? ` <!-- existing items rendered server-side -->` : '';
+        return `  <div class="mb-3">
+    <label class="form-label">${label}</label>
+    <div class="border rounded p-2" id="${name}-container">${editHint}
+      <div class="${name}-entry mb-2">
+        <select class="form-select form-select-sm mb-1" name="${name}[0]._type">
+          <option value="">-- Select type --</option>
+${typeOptions}
+        </select>
+${subFieldGroups}
+      </div>
+    </div>
+    <small class="text-muted">Add multiple ${label} entries as needed.</small>
   </div>`;
     }
     renderFormField(name, config, enumValues = [], isEdit = false) {
         const required = config.required ? 'required' : '';
         const label = (0, typeUtils_1.capitalize)(name);
-        const fieldType = (config.type || 'string').toLowerCase();
-        const capitalizedType = (0, typeUtils_1.capitalize)(fieldType);
+        const fieldType = (config.type || 'string');
+        const parsed = (0, typeUtils_1.parseFieldType)(fieldType);
+        // Array of union of value objects
+        if (parsed.isArray && parsed.isUnion) {
+            const unionVoNames = parsed.baseTypes.map(bt => (0, typeUtils_1.capitalize)(bt)).filter(n => this.valueObjects[n]);
+            if (unionVoNames.length > 0) {
+                return this.renderArrayUnionVoField(name, label, unionVoNames, isEdit);
+            }
+        }
+        // Array of value objects
+        if (parsed.isArray) {
+            const voName = (0, typeUtils_1.capitalize)(parsed.baseTypes[0]);
+            const voConfig = this.valueObjects[voName];
+            if (voConfig) {
+                return this.renderArrayVoField(name, label, voName, voConfig, isEdit);
+            }
+        }
+        // Union of value objects
+        if (parsed.isUnion) {
+            const unionVoNames = parsed.baseTypes.map(bt => (0, typeUtils_1.capitalize)(bt)).filter(n => this.valueObjects[n]);
+            if (unionVoNames.length > 0) {
+                return this.renderUnionVoField(name, label, unionVoNames, isEdit);
+            }
+        }
+        // Simple value object
+        const capitalizedType = (0, typeUtils_1.capitalize)(fieldType.toLowerCase());
         const voConfig = this.valueObjects[capitalizedType];
         if (voConfig) {
             return this.renderValueObjectField(name, label, voConfig, required, isEdit);

package/dist/utils/migrationUtils.d.ts

@@ -21,7 +21,7 @@ export interface ForeignKeyInfo {
     REFERENCED_TABLE_NAME: string;
     REFERENCED_COLUMN_NAME: string;
 }
-export declare function mapYamlTypeToSql(yamlType: string, availableAggregates: Set<string>): string;
+export declare function mapYamlTypeToSql(yamlType: string, availableAggregates: Set<string>, availableValueObjects?: Set<string>): string;
 export declare function getTableName(aggregateName: string): string;
 export declare function getForeignKeyFieldName(fieldName: string): string;
 export declare function isRelationshipField(fieldType: string, availableAggregates: Set<string>): boolean;

package/dist/utils/migrationUtils.js

@@ -52,6 +52,7 @@ exports.getMigrationFileName = getMigrationFileName;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const yaml_1 = require("yaml");
+const typeUtils_1 = require("./typeUtils");
 const TYPE_MAPPING = {
     string: 'VARCHAR(255)',
     number: 'INT',
@@ -61,10 +62,20 @@ const TYPE_MAPPING = {
     array: 'JSON',
     object: 'JSON'
 };
-function mapYamlTypeToSql(yamlType, availableAggregates) {
+function mapYamlTypeToSql(yamlType, availableAggregates, availableValueObjects) {
+    // Simple aggregate reference → foreign key INT
     if (availableAggregates.has(yamlType)) {
         return 'INT';
     }
+    // Compound types: array ("Foo[]") or union ("Foo | Bar") → JSON column
+    const parsed = (0, typeUtils_1.parseFieldType)(yamlType);
+    if (parsed.isArray || parsed.isUnion) {
+        return 'JSON';
+    }
+    // Named value object → stored as JSON
+    if (availableValueObjects && availableValueObjects.has(yamlType)) {
+        return 'JSON';
+    }
     return TYPE_MAPPING[yamlType] || 'VARCHAR(255)';
 }
 function getTableName(aggregateName) {

package/dist/utils/typeUtils.d.ts

@@ -9,8 +9,35 @@ export declare const TYPE_MAPPING: Record<string, string>;
 /** Store-specific: YAML type to DB row TypeScript type (e.g. datetime -> string). */
 export declare const ROW_TYPE_MAPPING: Record<string, string>;
 export declare function capitalize(str: string): string;
+/**
+ * Parsed representation of a compound YAML field type.
+ * Supports array syntax ("Foo[]") and union syntax ("Foo | Bar").
+ */
+export interface ParsedFieldType {
+    /** Individual base type names without modifiers. */
+    baseTypes: string[];
+    /** True when the type ends with "[]" (array of values). */
+    isArray: boolean;
+    /** True when the type contains "|" (union of types). */
+    isUnion: boolean;
+}
+/**
+ * Parse a YAML field type string into its structural components.
+ * Handles simple types ("Money"), array types ("Money[]"), union types ("Foo | Bar"),
+ * and array-of-union types ("(Foo | Bar)[]").
+ */
+export declare function parseFieldType(typeStr: string): ParsedFieldType;
+/**
+ * Returns true when any base type in the (possibly compound) type expression is a known value object.
+ */
+export declare function isValueObjectFieldType(typeStr: string, valueObjects: Set<string> | Map<string, unknown>): boolean;
+/**
+ * Returns the set of value object names referenced in a (possibly compound) type expression.
+ */
+export declare function getReferencedValueObjects(typeStr: string, valueObjects: Set<string> | Map<string, unknown>): Set<string>;
 /**
  * Map a YAML field type to TypeScript type, resolving aggregates and value objects by name.
+ * Supports compound types: "Foo[]" -> "Foo[]", "Foo | Bar" -> "Foo | Bar".
  */
 export declare function mapType(yamlType: string, aggregates?: Set<string> | Map<string, unknown>, valueObjects?: Set<string> | Map<string, unknown>): string;
 /**
@@ -18,6 +45,7 @@ export declare function mapType(yamlType: string, aggregates?: Set<string> | Map
  */
 export declare function isAggregateReference(yamlType: string, aggregates?: Set<string> | Map<string, unknown>): boolean;
 /**
- * Map a YAML type to the store row TypeScript type (value objects become string).
+ * Map a YAML type to the store row TypeScript type.
+ * Value objects (including compound types) become "string" (stored as JSON).
  */
 export declare function mapRowType(yamlType: string, valueObjects?: Set<string> | Map<string, unknown>): string;

package/dist/utils/typeUtils.js

@@ -5,6 +5,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ROW_TYPE_MAPPING = exports.TYPE_MAPPING = void 0;
 exports.capitalize = capitalize;
+exports.parseFieldType = parseFieldType;
+exports.isValueObjectFieldType = isValueObjectFieldType;
+exports.getReferencedValueObjects = getReferencedValueObjects;
 exports.mapType = mapType;
 exports.isAggregateReference = isAggregateReference;
 exports.mapRowType = mapRowType;
@@ -41,20 +44,111 @@ exports.ROW_TYPE_MAPPING = {
 function capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
+/**
+ * Parse a YAML field type string into its structural components.
+ * Handles simple types ("Money"), array types ("Money[]"), union types ("Foo | Bar"),
+ * and array-of-union types ("(Foo | Bar)[]").
+ */
+function parseFieldType(typeStr) {
+    const trimmed = typeStr.trim();
+    // Array of union: "(Foo | Bar)[]"
+    if (trimmed.startsWith('(') && trimmed.endsWith(')[]')) {
+        const inner = trimmed.slice(1, -3).trim();
+        const parts = inner.split('|').map(p => p.trim()).filter(Boolean);
+        return { baseTypes: parts, isArray: true, isUnion: true };
+    }
+    if (trimmed.endsWith('[]')) {
+        const base = trimmed.slice(0, -2).trim();
+        return { baseTypes: [base], isArray: true, isUnion: false };
+    }
+    if (trimmed.includes('|')) {
+        const parts = trimmed.split('|').map(p => p.trim()).filter(Boolean);
+        return { baseTypes: parts, isArray: false, isUnion: true };
+    }
+    return { baseTypes: [trimmed], isArray: false, isUnion: false };
+}
+/**
+ * Returns true when any base type in the (possibly compound) type expression is a known value object.
+ */
+function isValueObjectFieldType(typeStr, valueObjects) {
+    const { baseTypes } = parseFieldType(typeStr);
+    return baseTypes.some(bt => {
+        const cap = capitalize(bt);
+        return valueObjects instanceof Set ? valueObjects.has(cap) : valueObjects.has(cap);
+    });
+}
+/**
+ * Returns the set of value object names referenced in a (possibly compound) type expression.
+ */
+function getReferencedValueObjects(typeStr, valueObjects) {
+    const { baseTypes } = parseFieldType(typeStr);
+    const result = new Set();
+    for (const bt of baseTypes) {
+        const cap = capitalize(bt);
+        const has = valueObjects instanceof Set ? valueObjects.has(cap) : valueObjects.has(cap);
+        if (has)
+            result.add(cap);
+    }
+    return result;
+}
 /**
  * Map a YAML field type to TypeScript type, resolving aggregates and value objects by name.
+ * Supports compound types: "Foo[]" -> "Foo[]", "Foo | Bar" -> "Foo | Bar".
  */
 function mapType(yamlType, aggregates, valueObjects) {
-    var _a;
+    var _a, _b;
+    // Simple aggregate reference (no compound syntax)
     if (aggregates === null || aggregates === void 0 ? void 0 : aggregates.has(yamlType))
         return yamlType;
+    const parsed = parseFieldType(yamlType);
+    // Array of union of value objects: "(Foo | Bar)[]"
+    if (parsed.isArray && parsed.isUnion) {
+        const resolvedParts = parsed.baseTypes.map(bt => {
+            var _a;
+            const cap = capitalize(bt);
+            if (valueObjects) {
+                const has = valueObjects instanceof Set ? valueObjects.has(cap) : valueObjects.has(cap);
+                if (has)
+                    return cap;
+            }
+            return (_a = exports.TYPE_MAPPING[bt]) !== null && _a !== void 0 ? _a : 'any';
+        });
+        return `(${resolvedParts.join(' | ')})[]`;
+    }
+    // Array of value objects: "Foo[]"
+    if (parsed.isArray) {
+        const [base] = parsed.baseTypes;
+        const capitalizedBase = capitalize(base);
+        if (valueObjects) {
+            const has = valueObjects instanceof Set ? valueObjects.has(capitalizedBase) : valueObjects.has(capitalizedBase);
+            if (has)
+                return `${capitalizedBase}[]`;
+        }
+        // Fall back: treat as plain mapped type array
+        return `${(_a = exports.TYPE_MAPPING[base]) !== null && _a !== void 0 ? _a : 'any'}[]`;
+    }
+    // Union of value objects: "Foo | Bar"
+    if (parsed.isUnion) {
+        const resolvedParts = parsed.baseTypes.map(bt => {
+            var _a;
+            const cap = capitalize(bt);
+            if (valueObjects) {
+                const has = valueObjects instanceof Set ? valueObjects.has(cap) : valueObjects.has(cap);
+                if (has)
+                    return cap;
+            }
+            return (_a = exports.TYPE_MAPPING[bt]) !== null && _a !== void 0 ? _a : 'any';
+        });
+        return resolvedParts.join(' | ');
+    }
+    // Simple type
     const capitalizedType = capitalize(yamlType);
     if (valueObjects) {
         const has = valueObjects instanceof Set ? valueObjects.has(capitalizedType) : valueObjects.has(capitalizedType);
         if (has)
             return capitalizedType;
     }
-    return (_a = exports.TYPE_MAPPING[yamlType]) !== null && _a !== void 0 ? _a : 'any';
+    return (_b = exports.TYPE_MAPPING[yamlType]) !== null && _b !== void 0 ? _b : 'any';
 }
 /**
  * Check if a YAML field type references another aggregate entity.
@@ -63,14 +157,14 @@ function isAggregateReference(yamlType, aggregates) {
     return !!(aggregates === null || aggregates === void 0 ? void 0 : aggregates.has(yamlType));
 }
 /**
- * Map a YAML type to the store row TypeScript type (value objects become string).
+ * Map a YAML type to the store row TypeScript type.
+ * Value objects (including compound types) become "string" (stored as JSON).
  */
 function mapRowType(yamlType, valueObjects) {
     var _a;
     if (valueObjects) {
-        const capitalizedType = capitalize(yamlType);
-        const has = valueObjects instanceof Set ? valueObjects.has(capitalizedType) : valueObjects.has(capitalizedType);
-        if (has)
+        // Any compound type containing a VO name is stored as JSON string
+        if (isValueObjectFieldType(yamlType, valueObjects))
             return 'string';
     }
     return (_a = exports.ROW_TYPE_MAPPING[yamlType]) !== null && _a !== void 0 ? _a : 'string';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@currentjs/gen",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "CLI code generator",
   "license": "LGPL-3.0",
   "author": "Konstantin Zavalny",