@currentjs/gen 0.5.4 → 0.5.6

package/dist/types/configTypes.js

@@ -3,7 +3,22 @@
  * Type definitions for the Clean Architecture module configuration
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeIdentifierType = normalizeIdentifierType;
+exports.idTsType = idTsType;
 exports.isValidModuleConfig = isValidModuleConfig;
+function normalizeIdentifierType(value) {
+    const lower = value.toLowerCase();
+    if (lower === 'id' || lower === 'numeric')
+        return 'numeric';
+    if (lower === 'uuid')
+        return 'uuid';
+    if (lower === 'nanoid')
+        return 'nanoid';
+    throw new Error(`Unknown identifier type: "${value}". Expected: numeric, uuid, or nanoid`);
+}
+function idTsType(identifiers) {
+    return identifiers === 'numeric' ? 'number' : 'string';
+}
 // Type guard to validate module config (domain + useCases)
 function isValidModuleConfig(config) {
     return config && typeof config === 'object' && 'domain' in config && 'useCases' in config;

package/dist/utils/commandUtils.d.ts

@@ -28,7 +28,7 @@ export interface ModuleEntryResolved {
     path: string;
     database: string;
     styling: string;
-    identifiers: string;
+    identifiers: import('../types/configTypes').IdentifierType;
 }
 export declare function getModuleEntries(config: AppConfig): ModuleEntryResolved[];
 export declare function shouldIncludeModule(moduleYamlRel: string, moduleName?: string): boolean;

package/dist/utils/commandUtils.js

@@ -51,9 +51,10 @@ const serviceGenerator_1 = require("../generators/serviceGenerator");
 const controllerGenerator_1 = require("../generators/controllerGenerator");
 const storeGenerator_1 = require("../generators/storeGenerator");
 const templateGenerator_1 = require("../generators/templateGenerator");
+const configTypes_1 = require("../types/configTypes");
 const DEFAULT_DATABASE = 'mysql';
 const DEFAULT_STYLING = 'bootstrap';
-const DEFAULT_IDENTIFIERS = 'id';
+const DEFAULT_IDENTIFIERS = 'numeric';
 function loadAppConfig(yamlPath) {
     const raw = fs.readFileSync(yamlPath, 'utf8');
     const parsed = (0, yaml_1.parse)(raw);
@@ -81,7 +82,8 @@ function getModuleEntries(config) {
     const global = config.config || {};
     const database = (_a = global.database) !== null && _a !== void 0 ? _a : DEFAULT_DATABASE;
     const styling = (_b = global.styling) !== null && _b !== void 0 ? _b : DEFAULT_STYLING;
-    const identifiers = (_c = global.identifiers) !== null && _c !== void 0 ? _c : DEFAULT_IDENTIFIERS;
+    const rawIdentifiers = (_c = global.identifiers) !== null && _c !== void 0 ? _c : DEFAULT_IDENTIFIERS;
+    const identifiers = (0, configTypes_1.normalizeIdentifierType)(rawIdentifiers);
     const globalConfig = { database, styling, identifiers };
     return Object.entries(config.modules).map(([name, entry]) => {
         var _a, _b, _c;
@@ -90,7 +92,7 @@ function getModuleEntries(config) {
             path: entry.path,
             database: (_a = entry.database) !== null && _a !== void 0 ? _a : globalConfig.database,
             styling: (_b = entry.styling) !== null && _b !== void 0 ? _b : globalConfig.styling,
-            identifiers: (_c = entry.identifiers) !== null && _c !== void 0 ? _c : globalConfig.identifiers
+            identifiers: (0, configTypes_1.normalizeIdentifierType)((_c = entry.identifiers) !== null && _c !== void 0 ? _c : globalConfig.identifiers)
         });
     });
 }

package/dist/utils/migrationUtils.d.ts

@@ -1,4 +1,4 @@
-import { AggregateConfig, AggregateFieldConfig } from '../types/configTypes';
+import { AggregateConfig, AggregateFieldConfig, IdentifierType } from '../types/configTypes';
 export interface SchemaState {
     aggregates: Record<string, AggregateConfig>;
     version: string;
@@ -21,19 +21,27 @@ export interface ForeignKeyInfo {
     REFERENCED_TABLE_NAME: string;
     REFERENCED_COLUMN_NAME: string;
 }
-export declare function mapYamlTypeToSql(yamlType: string, availableAggregates: Set<string>, availableValueObjects?: Set<string>): string;
+export declare function getIdColumnDefinition(idType?: IdentifierType): string;
+export declare function getFkColumnType(idType?: IdentifierType): string;
+export declare function mapYamlTypeToSql(yamlType: string, availableAggregates: Set<string>, availableValueObjects?: Set<string>, identifiers?: IdentifierType): 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, identifiers?: IdentifierType): 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>, identifiers?: IdentifierType): 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>, identifiers?: IdentifierType): 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>, identifiers?: IdentifierType): string[];
 export declare function generateTimestamp(): string;
 export declare function getMigrationFileName(timestamp: string): string;

package/dist/utils/migrationUtils.js

@@ -33,10 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdColumnDefinition = getIdColumnDefinition;
+exports.getFkColumnType = getFkColumnType;
 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,16 +59,34 @@ 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, availableValueObjects) {
-    // Simple aggregate reference → foreign key INT
+function getIdColumnDefinition(idType = 'numeric') {
+    switch (idType) {
+        case 'uuid': return 'id BINARY(16) PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID(), 1))';
+        case 'nanoid': return 'id VARCHAR(21) PRIMARY KEY';
+        default: return 'id INT AUTO_INCREMENT PRIMARY KEY';
+    }
+}
+function getFkColumnType(idType = 'numeric') {
+    switch (idType) {
+        case 'uuid': return 'BINARY(16)';
+        case 'nanoid': return 'VARCHAR(21)';
+        default: return 'INT';
+    }
+}
+function mapYamlTypeToSql(yamlType, availableAggregates, availableValueObjects, identifiers = 'numeric') {
+    // Simple aggregate reference → foreign key column matching PK type
     if (availableAggregates.has(yamlType)) {
-        return 'INT';
+        return getFkColumnType(identifiers);
     }
     // Compound types: array ("Foo[]") or union ("Foo | Bar") → JSON column
     const parsed = (0, typeUtils_1.parseFieldType)(yamlType);
@@ -78,8 +99,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,17 +109,40 @@ 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, identifiers = 'numeric') {
     const tableName = getTableName(name);
     const columns = [];
     const indexes = [];
     const foreignKeys = [];
-    columns.push('  id INT AUTO_INCREMENT PRIMARY KEY');
+    const fkType = getFkColumnType(identifiers);
+    columns.push(`  ${getIdColumnDefinition(identifiers)}`);
+    // Root aggregates get an ownerId column; child entities get a parent ID column.
+    if (parentIdField) {
+        columns.push(`  ${parentIdField} ${fkType} NOT NULL`);
+        indexes.push(`  INDEX idx_${tableName}_${parentIdField} (${parentIdField})`);
+    }
+    else if (aggregate.root !== false) {
+        columns.push(`  ownerId ${fkType} 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);
             const nullable = field.required === false ? 'NULL DEFAULT NULL' : 'NOT NULL';
-            columns.push(`  ${foreignKeyName} INT ${nullable}`);
+            columns.push(`  ${foreignKeyName} ${fkType} ${nullable}`);
             indexes.push(`  INDEX idx_${tableName}_${foreignKeyName} (${foreignKeyName})`);
             const refTableName = getTableName(field.type);
             foreignKeys.push(`  CONSTRAINT fk_${tableName}_${foreignKeyName} \n` +
@@ -107,50 +152,50 @@ function generateCreateTableSQL(name, aggregate, availableAggregates) {
                 `    ON UPDATE CASCADE`);
         }
         else {
-            const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
+            const sqlType = mapYamlTypeToSql(field.type, availableAggregates, availableValueObjects, identifiers);
             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, identifiers = 'numeric') {
     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}\` ${getFkColumnType(identifiers)} ${nullable};`;
     }
     else {
-        const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
+        const sqlType = mapYamlTypeToSql(field.type, availableAggregates, availableValueObjects, identifiers);
         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, identifiers = 'numeric') {
     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}\` ${getFkColumnType(identifiers)} ${nullable};`;
     }
     else {
-        const sqlType = mapYamlTypeToSql(field.type, availableAggregates);
+        const sqlType = mapYamlTypeToSql(field.type, availableAggregates, availableValueObjects, identifiers);
         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 +242,18 @@ function sortAggregatesByDependencies(aggregates, availableAggregates) {
     }
     return sorted;
 }
-function compareSchemas(oldState, newAggregates) {
+function compareSchemas(oldState, newAggregates, availableValueObjects, identifiers = 'numeric') {
     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, identifiers));
             sqlStatements.push('');
         }
         return sqlStatements;
@@ -223,9 +272,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, identifiers));
             sqlStatements.push('');
         }
         else {
@@ -247,7 +298,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, identifiers));
                     sqlStatements.push('');
                 }
                 else {
@@ -255,7 +306,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, identifiers));
                         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.6",
   "description": "CLI code generator",
   "license": "LGPL-3.0",
   "author": "Konstantin Zavalny",