@currentjs/gen 0.5.4 → 0.5.5

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # 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

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/storeGenerator.js

@@ -130,7 +130,7 @@ class StoreGenerator {
         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]];
@@ -141,7 +141,7 @@ 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) {
@@ -149,7 +149,7 @@ class StoreGenerator {
         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})) : []`;
+        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) {
@@ -161,7 +161,7 @@ class StoreGenerator {
                 : '...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`;
+        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) {
@@ -181,7 +181,7 @@ class StoreGenerator {
                 : '...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; }) : []`;
+        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) {
@@ -204,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);
@@ -216,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) {
@@ -233,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
@@ -283,7 +283,7 @@ class StoreGenerator {
                     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;
             }
@@ -299,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
@@ -342,7 +342,7 @@ 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');
@@ -371,7 +371,7 @@ 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 = [];
@@ -423,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
     );
 
@@ -435,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
     );
 
@@ -447,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
     );
 
@@ -461,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 }
     );
 
@@ -489,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 }
     );
 
@@ -507,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/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

@@ -22,18 +22,24 @@ export interface ForeignKeyInfo {
     REFERENCED_COLUMN_NAME: 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;
@@ -56,8 +57,12 @@ 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'
@@ -78,8 +83,9 @@ function mapYamlTypeToSql(yamlType, availableAggregates, availableValueObjects)
     }
     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';
@@ -87,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);
@@ -107,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) {
@@ -197,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;
@@ -223,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 {
@@ -247,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 {
@@ -255,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.js

@@ -36,9 +36,9 @@ exports.ROW_TYPE_MAPPING = {
     datetime: 'string',
     date: 'string',
     id: 'number',
-    json: 'string',
-    array: 'string',
-    object: 'string',
+    json: 'any',
+    array: 'any[]',
+    object: 'any',
     enum: 'string'
 };
 function capitalize(str) {

package/package.json

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