@currentjs/gen 0.5.3 → 0.5.5

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/generators/templates/storeTemplates.js

@@ -5,9 +5,9 @@ exports.storeTemplates = {
     rowInterface: `export interface {{ENTITY_NAME}}Row {
   id: number;
 {{ROW_FIELDS}}
-  created_at: string;
-  updated_at: string;
-  deleted_at?: string;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
 }`,
     storeClass: `/**
  * Data access layer for {{ENTITY_NAME}}
@@ -22,6 +22,10 @@ export class {{ENTITY_NAME}}Store {
     return date.toISOString().slice(0, 19).replace('T', ' ');
   }
 
+  private ensureParsed(value: any): any {
+    return typeof value === 'string' ? JSON.parse(value) : value;
+  }
+
   private rowToModel(row: {{ENTITY_NAME}}Row): {{ENTITY_NAME}} {
     return new {{ENTITY_NAME}}(
       row.id,
@@ -33,7 +37,7 @@ export class {{ENTITY_NAME}}Store {
 
   async getById(id: number): Promise<{{ENTITY_NAME}} | null> {
     const result = await this.db.query(
-      \`SELECT {{FIELD_NAMES}} FROM \\\`\${this.tableName}\\\` WHERE id = :id AND deleted_at IS NULL\`,
+      \`SELECT {{FIELD_NAMES}} FROM \\\`\${this.tableName}\\\` WHERE id = :id AND deletedAt IS NULL\`,
       { id }
     );
 
@@ -47,16 +51,17 @@ export class {{ENTITY_NAME}}Store {
     const now = new Date();
     const data: Partial<{{ENTITY_NAME}}Row> = {
 {{INSERT_DATA_MAPPING}},
-      created_at: this.toMySQLDatetime(now),
-      updated_at: this.toMySQLDatetime(now)
+      createdAt: this.toMySQLDatetime(now),
+      updatedAt: this.toMySQLDatetime(now)
     };
 
-    const fieldsList = Object.keys(data).map(f => \`\\\`\${f}\\\`\`).join(', ');
-    const placeholders = Object.keys(data).map(f => \`:\${f}\`).join(', ');
+    const cleanData = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined));
+    const fieldsList = Object.keys(cleanData).map(f => \`\\\`\${f}\\\`\`).join(', ');
+    const placeholders = Object.keys(cleanData).map(f => \`:\${f}\`).join(', ');
 
     const result = await this.db.query(
       \`INSERT INTO \\\`\${this.tableName}\\\` (\${fieldsList}) VALUES (\${placeholders})\`,
-      data
+      cleanData
     );
 
     if (result.success && result.insertId) {
@@ -69,17 +74,19 @@ export class {{ENTITY_NAME}}Store {
 
   async update(id: number, entity: {{ENTITY_NAME}}): Promise<{{ENTITY_NAME}}> {
     const now = new Date();
-    const data: Partial<{{ENTITY_NAME}}Row> & { id: number } = {
+    const rawData: Partial<{{ENTITY_NAME}}Row> = {
 {{UPDATE_DATA_MAPPING}},
-      updated_at: this.toMySQLDatetime(now),
-      id
+      updatedAt: this.toMySQLDatetime(now)
     };
 
-    const updateFields = {{UPDATE_FIELDS_ARRAY}}.map(f => \`\\\`\${f}\\\` = :\${f}\`).join(', ');
+    const cleanData = Object.fromEntries(Object.entries(rawData).filter(([, v]) => v !== undefined));
+    const updateFields = {{UPDATE_FIELDS_ARRAY}}
+      .filter(f => f in cleanData)
+      .map(f => \`\\\`\${f}\\\` = :\${f}\`).join(', ');
 
     const result = await this.db.query(
-      \`UPDATE \\\`\${this.tableName}\\\` SET \${updateFields}, updated_at = :updated_at WHERE id = :id\`,
-      data
+      \`UPDATE \\\`\${this.tableName}\\\` SET \${updateFields}, updatedAt = :updatedAt WHERE id = :id\`,
+      { ...cleanData, id }
     );
 
     if (result.success) {
@@ -92,8 +99,8 @@ export class {{ENTITY_NAME}}Store {
   async softDelete(id: number): Promise<boolean> {
     const now = new Date();
     const result = await this.db.query(
-      \`UPDATE \\\`\${this.tableName}\\\` SET deleted_at = :deleted_at WHERE id = :id\`,
-      { deleted_at: this.toMySQLDatetime(now), id }
+      \`UPDATE \\\`\${this.tableName}\\\` SET deletedAt = :deletedAt WHERE id = :id\`,
+      { deletedAt: this.toMySQLDatetime(now), id }
     );
 
     return result.success;

package/dist/utils/migrationUtils.d.ts

@@ -21,19 +21,25 @@ 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;
+/** Table name matches the store convention: singular lowercase aggregate name. */
 export declare function getTableName(aggregateName: string): string;
 export declare function getForeignKeyFieldName(fieldName: string): string;
 export declare function isRelationshipField(fieldType: string, availableAggregates: Set<string>): boolean;
-export declare function generateCreateTableSQL(name: string, aggregate: AggregateConfig, availableAggregates: Set<string>): string;
+/**
+ * Build a map of child entity name → parent entity name from the aggregates config.
+ * Used to determine parent ID column names for child entity tables.
+ */
+export declare function buildChildToParentMap(aggregates: Record<string, AggregateConfig>): Map<string, string>;
+export declare function generateCreateTableSQL(name: string, aggregate: AggregateConfig, availableAggregates: Set<string>, availableValueObjects?: Set<string>, parentIdField?: string): string;
 export declare function generateDropTableSQL(tableName: string): string;
-export declare function generateAddColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>): string;
+export declare function generateAddColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>, availableValueObjects?: Set<string>): string;
 export declare function generateDropColumnSQL(tableName: string, columnName: string): string;
-export declare function generateModifyColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>): string;
+export declare function generateModifyColumnSQL(tableName: string, fieldName: string, field: AggregateFieldConfig, availableAggregates: Set<string>, availableValueObjects?: Set<string>): string;
 export declare function loadSchemaState(stateFilePath: string): SchemaState | null;
 export declare function saveSchemaState(stateFilePath: string, state: SchemaState): void;
 export declare function loadMigrationLog(logFilePath: string): MigrationLog;
 export declare function saveMigrationLog(logFilePath: string, log: MigrationLog): void;
-export declare function compareSchemas(oldState: SchemaState | null, newAggregates: Record<string, AggregateConfig>): string[];
+export declare function compareSchemas(oldState: SchemaState | null, newAggregates: Record<string, AggregateConfig>, availableValueObjects?: Set<string>): string[];
 export declare function generateTimestamp(): string;
 export declare function getMigrationFileName(timestamp: string): string;

package/dist/utils/migrationUtils.js

@@ -37,6 +37,7 @@ exports.mapYamlTypeToSql = mapYamlTypeToSql;
 exports.getTableName = getTableName;
 exports.getForeignKeyFieldName = getForeignKeyFieldName;
 exports.isRelationshipField = isRelationshipField;
+exports.buildChildToParentMap = buildChildToParentMap;
 exports.generateCreateTableSQL = generateCreateTableSQL;
 exports.generateDropTableSQL = generateDropTableSQL;
 exports.generateAddColumnSQL = generateAddColumnSQL;
@@ -52,23 +53,39 @@ 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',
+    integer: 'INT',
+    decimal: 'DECIMAL(10,2)',
     boolean: 'TINYINT(1)',
     datetime: 'DATETIME',
+    date: 'DATETIME',
+    id: 'INT',
     json: 'JSON',
     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)';
 }
+/** Table name matches the store convention: singular lowercase aggregate name. */
 function getTableName(aggregateName) {
-    return aggregateName.toLowerCase() + 's';
+    return aggregateName.toLowerCase();
 }
 function getForeignKeyFieldName(fieldName) {
     return fieldName + 'Id';
@@ -76,12 +93,34 @@ function getForeignKeyFieldName(fieldName) {
 function isRelationshipField(fieldType, availableAggregates) {
     return availableAggregates.has(fieldType);
 }
-function generateCreateTableSQL(name, aggregate, availableAggregates) {
+/**
+ * Build a map of child entity name → parent entity name from the aggregates config.
+ * Used to determine parent ID column names for child entity tables.
+ */
+function buildChildToParentMap(aggregates) {
+    const map = new Map();
+    for (const [parentName, config] of Object.entries(aggregates)) {
+        for (const childName of (config.entities || [])) {
+            map.set(childName, parentName);
+        }
+    }
+    return map;
+}
+function generateCreateTableSQL(name, aggregate, availableAggregates, availableValueObjects, parentIdField) {
     const tableName = getTableName(name);
     const columns = [];
     const indexes = [];
     const foreignKeys = [];
     columns.push('  id INT AUTO_INCREMENT PRIMARY KEY');
+    // Root aggregates get an ownerId column; child entities get a parent ID column.
+    if (parentIdField) {
+        columns.push(`  ${parentIdField} INT NOT NULL`);
+        indexes.push(`  INDEX idx_${tableName}_${parentIdField} (${parentIdField})`);
+    }
+    else if (aggregate.root !== false) {
+        columns.push('  ownerId INT NOT NULL');
+        indexes.push(`  INDEX idx_${tableName}_ownerId (ownerId)`);
+    }
     for (const [fieldName, field] of Object.entries(aggregate.fields)) {
         if (isRelationshipField(field.type, availableAggregates)) {
             const foreignKeyName = getForeignKeyFieldName(fieldName);
@@ -96,50 +135,50 @@ function generateCreateTableSQL(name, aggregate, availableAggregates) {
                 `    ON UPDATE CASCADE`);
         }
         else {
-            const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
+            const sqlType = mapYamlTypeToSql(field.type, availableAggregates, availableValueObjects);
             const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
             columns.push(`  ${fieldName} ${sqlType} ${nullable}`);
-            if (['string', 'number'].includes(field.type)) {
+            if (['string', 'number', 'integer', 'id'].includes(field.type)) {
                 indexes.push(`  INDEX idx_${tableName}_${fieldName} (${fieldName})`);
             }
         }
     }
-    columns.push('  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP');
-    columns.push('  updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP');
-    columns.push('  deleted_at DATETIME NULL DEFAULT NULL');
-    indexes.push(`  INDEX idx_${tableName}_deleted_at (deleted_at)`);
-    indexes.push(`  INDEX idx_${tableName}_created_at (created_at)`);
+    columns.push('  createdAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP');
+    columns.push('  updatedAt DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP');
+    columns.push('  deletedAt DATETIME NULL DEFAULT NULL');
+    indexes.push(`  INDEX idx_${tableName}_deletedAt (deletedAt)`);
+    indexes.push(`  INDEX idx_${tableName}_createdAt (createdAt)`);
     const allParts = [...columns, ...indexes, ...foreignKeys];
-    return `CREATE TABLE IF NOT EXISTS ${tableName} (\n${allParts.join(',\n')}\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;`;
+    return `CREATE TABLE IF NOT EXISTS \`${tableName}\` (\n${allParts.join(',\n')}\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;`;
 }
 function generateDropTableSQL(tableName) {
-    return `DROP TABLE IF EXISTS ${tableName};`;
+    return `DROP TABLE IF EXISTS \`${tableName}\`;`;
 }
-function generateAddColumnSQL(tableName, fieldName, field, availableAggregates) {
+function generateAddColumnSQL(tableName, fieldName, field, availableAggregates, availableValueObjects) {
     if (isRelationshipField(field.type, availableAggregates)) {
         const foreignKeyName = getForeignKeyFieldName(fieldName);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        return `ALTER TABLE ${tableName} ADD COLUMN ${foreignKeyName} INT ${nullable};`;
+        return `ALTER TABLE \`${tableName}\` ADD COLUMN \`${foreignKeyName}\` INT ${nullable};`;
     }
     else {
-        const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
+        const sqlType = mapYamlTypeToSql(field.type, availableAggregates, availableValueObjects);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        return `ALTER TABLE ${tableName} ADD COLUMN ${fieldName} ${sqlType} ${nullable};`;
+        return `ALTER TABLE \`${tableName}\` ADD COLUMN \`${fieldName}\` ${sqlType} ${nullable};`;
     }
 }
 function generateDropColumnSQL(tableName, columnName) {
-    return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
+    return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
 }
-function generateModifyColumnSQL(tableName, fieldName, field, availableAggregates) {
+function generateModifyColumnSQL(tableName, fieldName, field, availableAggregates, availableValueObjects) {
     if (isRelationshipField(field.type, availableAggregates)) {
         const foreignKeyName = getForeignKeyFieldName(fieldName);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        return `ALTER TABLE ${tableName} MODIFY COLUMN ${foreignKeyName} INT ${nullable};`;
+        return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${foreignKeyName}\` INT ${nullable};`;
     }
     else {
-        const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
+        const sqlType = mapYamlTypeToSql(field.type, availableAggregates, availableValueObjects);
         const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-        return `ALTER TABLE ${tableName} MODIFY COLUMN ${fieldName} ${sqlType} ${nullable};`;
+        return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${fieldName}\` ${sqlType} ${nullable};`;
     }
 }
 function loadSchemaState(stateFilePath) {
@@ -186,14 +225,18 @@ function sortAggregatesByDependencies(aggregates, availableAggregates) {
     }
     return sorted;
 }
-function compareSchemas(oldState, newAggregates) {
+function compareSchemas(oldState, newAggregates, availableValueObjects) {
     const sqlStatements = [];
     const availableAggregates = new Set(Object.keys(newAggregates));
+    const childToParent = buildChildToParentMap(newAggregates);
     if (!oldState || !oldState.aggregates || Object.keys(oldState.aggregates).length === 0) {
         const sorted = sortAggregatesByDependencies(newAggregates, availableAggregates);
         for (const [name, aggregate] of sorted) {
-            sqlStatements.push(`-- Create ${name.toLowerCase()}s table`);
-            sqlStatements.push(generateCreateTableSQL(name, aggregate, availableAggregates));
+            const tableName = getTableName(name);
+            const parentName = childToParent.get(name);
+            const parentIdField = parentName ? `${parentName.toLowerCase()}Id` : undefined;
+            sqlStatements.push(`-- Create ${tableName} table`);
+            sqlStatements.push(generateCreateTableSQL(name, aggregate, availableAggregates, availableValueObjects, parentIdField));
             sqlStatements.push('');
         }
         return sqlStatements;
@@ -212,9 +255,11 @@ function compareSchemas(oldState, newAggregates) {
     for (const [name, newAggregate] of Object.entries(newAggregates)) {
         const oldAggregate = oldAggregates[name];
         const tableName = getTableName(name);
+        const parentName = childToParent.get(name);
+        const parentIdField = parentName ? `${parentName.toLowerCase()}Id` : undefined;
         if (!oldAggregate) {
             sqlStatements.push(`-- Create ${tableName} table`);
-            sqlStatements.push(generateCreateTableSQL(name, newAggregate, availableAggregates));
+            sqlStatements.push(generateCreateTableSQL(name, newAggregate, availableAggregates, availableValueObjects, parentIdField));
             sqlStatements.push('');
         }
         else {
@@ -236,7 +281,7 @@ function compareSchemas(oldState, newAggregates) {
                 const oldField = oldFields[fieldName];
                 if (!oldField) {
                     sqlStatements.push(`-- Add column ${fieldName} to ${tableName}`);
-                    sqlStatements.push(generateAddColumnSQL(tableName, fieldName, newField, availableAggregates));
+                    sqlStatements.push(generateAddColumnSQL(tableName, fieldName, newField, availableAggregates, availableValueObjects));
                     sqlStatements.push('');
                 }
                 else {
@@ -244,7 +289,7 @@ function compareSchemas(oldState, newAggregates) {
                     const requiredChanged = oldField.required !== newField.required;
                     if (typeChanged || requiredChanged) {
                         sqlStatements.push(`-- Modify column ${fieldName} in ${tableName}`);
-                        sqlStatements.push(generateModifyColumnSQL(tableName, fieldName, newField, availableAggregates));
+                        sqlStatements.push(generateModifyColumnSQL(tableName, fieldName, newField, availableAggregates, availableValueObjects));
                         sqlStatements.push('');
                     }
                 }

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;