@currentjs/gen 0.5.5 → 0.5.7

package/dist/generators/useCaseGenerator.js

@@ -44,6 +44,7 @@ const typeUtils_1 = require("../utils/typeUtils");
 class UseCaseGenerator {
     constructor() {
         this.availableAggregates = new Map();
+        this.identifiers = 'numeric';
     }
     generateUseCaseMethod(modelName, actionName, useCaseConfig) {
         const methodName = actionName;
@@ -100,7 +101,7 @@ class UseCaseGenerator {
         }).join('\n');
         const returnStatement = '\n    return result;';
         const methodParams = actionName === 'list'
-            ? `input: ${inputType}, ownerId?: number`
+            ? `input: ${inputType}, ownerId?: ${(0, configTypes_1.idTsType)(this.identifiers)}`
             : `input: ${inputType}`;
         return `  async ${methodName}(${methodParams}): Promise<${returnType}> {
 ${handlerCalls}${returnStatement}
@@ -108,12 +109,13 @@ ${handlerCalls}${returnStatement}
     }
     generateGetResourceOwnerMethod(modelName) {
         const serviceVar = `${modelName.toLowerCase()}Service`;
+        const idTs = (0, configTypes_1.idTsType)(this.identifiers);
         return `
   /**
    * Get the owner ID of a resource by its ID.
    * Used for pre-mutation authorization checks in controllers.
    */
-  async getResourceOwner(id: number): Promise<number | null> {
+  async getResourceOwner(id: ${idTs}): Promise<${idTs} | null> {
     return await this.${serviceVar}.getResourceOwner(id);
   }`;
     }
@@ -151,9 +153,10 @@ export class ${className} {
 ${methods}${getResourceOwnerMethod}
 }`;
     }
-    generateFromConfig(config) {
+    generateFromConfig(config, identifiers = 'numeric') {
         var _a;
         const result = {};
+        this.identifiers = identifiers;
         // Collect all aggregates to know which are roots
         this.availableAggregates.clear();
         if ((_a = config.domain) === null || _a === void 0 ? void 0 : _a.aggregates) {
@@ -167,16 +170,16 @@ ${methods}${getResourceOwnerMethod}
         });
         return result;
     }
-    generateFromYamlFile(yamlFilePath) {
+    generateFromYamlFile(yamlFilePath, identifiers = 'numeric') {
         const yamlContent = fs.readFileSync(yamlFilePath, 'utf8');
         const config = (0, yaml_1.parse)(yamlContent);
         if (!(0, configTypes_1.isValidModuleConfig)(config)) {
             throw new Error('Configuration does not match new module format. Expected useCases structure.');
         }
-        return this.generateFromConfig(config);
+        return this.generateFromConfig(config, identifiers);
     }
-    async generateAndSaveFiles(yamlFilePath, moduleDir, opts) {
-        const useCasesByModel = this.generateFromYamlFile(yamlFilePath);
+    async generateAndSaveFiles(yamlFilePath, moduleDir, opts, identifiers = 'numeric') {
+        const useCasesByModel = this.generateFromYamlFile(yamlFilePath, identifiers);
         const useCasesDir = path.join(moduleDir, 'application', 'useCases');
         fs.mkdirSync(useCasesDir, { recursive: true });
         for (const [modelName, code] of Object.entries(useCasesByModel)) {

package/dist/types/configTypes.d.ts

@@ -1,6 +1,9 @@
 /**
  * Type definitions for the Clean Architecture module configuration
  */
+export type IdentifierType = 'numeric' | 'uuid' | 'nanoid';
+export declare function normalizeIdentifierType(value: string): IdentifierType;
+export declare function idTsType(identifiers: IdentifierType): 'number' | 'string';
 export interface FieldDefinition {
     type: string;
     constraints?: {

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,7 +21,9 @@ 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;
@@ -31,15 +33,15 @@ export declare function isRelationshipField(fieldType: string, availableAggregat
  * 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 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>, availableValueObjects?: 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>, availableValueObjects?: 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>, availableValueObjects?: Set<string>): 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,6 +33,8 @@ 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;
@@ -67,10 +69,24 @@ const TYPE_MAPPING = {
     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);
@@ -106,26 +122,27 @@ function buildChildToParentMap(aggregates) {
     }
     return map;
 }
-function generateCreateTableSQL(name, aggregate, availableAggregates, availableValueObjects, parentIdField) {
+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} INT NOT NULL`);
+        columns.push(`  ${parentIdField} ${fkType} NOT NULL`);
         indexes.push(`  INDEX idx_${tableName}_${parentIdField} (${parentIdField})`);
     }
     else if (aggregate.root !== false) {
-        columns.push('  ownerId INT NOT NULL');
+        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` +
@@ -135,7 +152,7 @@ function generateCreateTableSQL(name, aggregate, availableAggregates, availableV
                 `    ON UPDATE CASCADE`);
         }
         else {
-            const sqlType = mapYamlTypeToSql(field.type, availableAggregates, availableValueObjects);
+            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', 'integer', 'id'].includes(field.type)) {
@@ -154,14 +171,14 @@ function generateCreateTableSQL(name, aggregate, availableAggregates, availableV
 function generateDropTableSQL(tableName) {
     return `DROP TABLE IF EXISTS \`${tableName}\`;`;
 }
-function generateAddColumnSQL(tableName, fieldName, field, availableAggregates, availableValueObjects) {
+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, availableValueObjects);
+        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};`;
     }
@@ -169,14 +186,14 @@ function generateAddColumnSQL(tableName, fieldName, field, availableAggregates,
 function generateDropColumnSQL(tableName, columnName) {
     return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
 }
-function generateModifyColumnSQL(tableName, fieldName, field, availableAggregates, availableValueObjects) {
+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, availableValueObjects);
+        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};`;
     }
@@ -225,7 +242,7 @@ function sortAggregatesByDependencies(aggregates, availableAggregates) {
     }
     return sorted;
 }
-function compareSchemas(oldState, newAggregates, availableValueObjects) {
+function compareSchemas(oldState, newAggregates, availableValueObjects, identifiers = 'numeric') {
     const sqlStatements = [];
     const availableAggregates = new Set(Object.keys(newAggregates));
     const childToParent = buildChildToParentMap(newAggregates);
@@ -236,7 +253,7 @@ function compareSchemas(oldState, newAggregates, availableValueObjects) {
             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(generateCreateTableSQL(name, aggregate, availableAggregates, availableValueObjects, parentIdField, identifiers));
             sqlStatements.push('');
         }
         return sqlStatements;
@@ -259,7 +276,7 @@ function compareSchemas(oldState, newAggregates, availableValueObjects) {
         const parentIdField = parentName ? `${parentName.toLowerCase()}Id` : undefined;
         if (!oldAggregate) {
             sqlStatements.push(`-- Create ${tableName} table`);
-            sqlStatements.push(generateCreateTableSQL(name, newAggregate, availableAggregates, availableValueObjects, parentIdField));
+            sqlStatements.push(generateCreateTableSQL(name, newAggregate, availableAggregates, availableValueObjects, parentIdField, identifiers));
             sqlStatements.push('');
         }
         else {
@@ -281,7 +298,7 @@ function compareSchemas(oldState, newAggregates, availableValueObjects) {
                 const oldField = oldFields[fieldName];
                 if (!oldField) {
                     sqlStatements.push(`-- Add column ${fieldName} to ${tableName}`);
-                    sqlStatements.push(generateAddColumnSQL(tableName, fieldName, newField, availableAggregates, availableValueObjects));
+                    sqlStatements.push(generateAddColumnSQL(tableName, fieldName, newField, availableAggregates, availableValueObjects, identifiers));
                     sqlStatements.push('');
                 }
                 else {
@@ -289,7 +306,7 @@ function compareSchemas(oldState, newAggregates, availableValueObjects) {
                     const requiredChanged = oldField.required !== newField.required;
                     if (typeChanged || requiredChanged) {
                         sqlStatements.push(`-- Modify column ${fieldName} in ${tableName}`);
-                        sqlStatements.push(generateModifyColumnSQL(tableName, fieldName, newField, availableAggregates, availableValueObjects));
+                        sqlStatements.push(generateModifyColumnSQL(tableName, fieldName, newField, availableAggregates, availableValueObjects, identifiers));
                         sqlStatements.push('');
                     }
                 }

package/package.json

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