@vira-ui/cli 1.1.1 → 1.2.0

package/dist/index.js

@@ -91,7 +91,7 @@ const program = new commander_1.Command();
 program
     .name("vira")
     .description("ViraJS CLI - Create projects and generate code")
-    .version("1.1.1");
+    .version("1.2.0");
 const SUPPORTED_TEMPLATES = ["frontend", "fullstack", "kanban"];
 /**
  * Инициализация проекта в текущей директории
@@ -292,6 +292,48 @@ make
     await generateMigration(name, options.dir);
     console.log(chalk_1.default.green(`✓ migration ${name} created in ${options.dir}`));
 });
+// Команды для выполнения миграций
+const dbCommand = program
+    .command("db")
+    .description("Database migration commands");
+dbCommand
+    .command("migrate")
+    .alias("up")
+    .description("Run database migrations")
+    .option("-d, --dir <directory>", "Migrations directory", "migrations")
+    .option("--db-url <url>", "Database connection URL (or use DATABASE_URL env var)")
+    .option("--driver <driver>", "Database driver (postgres, mysql, sqlite3)", "postgres")
+    .action(async (options) => {
+    await runMigrations(options.dir || "migrations", options.dbUrl, options.driver || "postgres", "up");
+});
+dbCommand
+    .command("rollback")
+    .alias("down")
+    .description("Rollback last migration")
+    .option("-d, --dir <directory>", "Migrations directory", "migrations")
+    .option("--db-url <url>", "Database connection URL (or use DATABASE_URL env var)")
+    .option("--driver <driver>", "Database driver (postgres, mysql, sqlite3)", "postgres")
+    .action(async (options) => {
+    await runMigrations(options.dir || "migrations", options.dbUrl, options.driver || "postgres", "down");
+});
+dbCommand
+    .command("status")
+    .description("Show migration status")
+    .option("-d, --dir <directory>", "Migrations directory", "migrations")
+    .option("--db-url <url>", "Database connection URL (or use DATABASE_URL env var)")
+    .option("--driver <driver>", "Database driver (postgres, mysql, sqlite3)", "postgres")
+    .action(async (options) => {
+    await showMigrationStatus(options.dir || "migrations", options.dbUrl, options.driver || "postgres");
+});
+dbCommand
+    .command("seed")
+    .description("Run database seeds")
+    .option("-d, --dir <directory>", "Seeds directory", "seeds")
+    .option("--db-url <url>", "Database connection URL (or use DATABASE_URL env var)")
+    .option("--driver <driver>", "Database driver (postgres, mysql, sqlite3)", "postgres")
+    .action(async (options) => {
+    await runSeeds(options.dir || "seeds", options.dbUrl, options.driver || "postgres");
+});
 make
     .command("event")
     .description("Create Go event handler stub")
@@ -433,6 +475,8 @@ program
     .description("Sync artifacts between backend and frontend")
     .option("--types", "Sync TypeScript types from Go structs", true)
     .option("--backend <path>", "Path to Go types file", path.join("backend", "internal", "types", "types.go"))
+    .option("--from-models", "Generate TS types from Go models directory (backend/internal/models)", false)
+    .option("--models <path>", "Path to Go models directory", path.join("backend", "internal", "models"))
     .option("--frontend <path>", "Output TS types path (frontend)", path.join("frontend", "src", "vira-types.ts"))
     .option("--ui <path>", "Output TS types path (ui)", path.join("ui", "src", "vira-types.ts"))
     .option("-w, --watch", "Watch mode: automatically sync on file changes", false)
@@ -828,7 +872,29 @@ ${props.map((p) => `  ${p.name}${p.required ? "" : "?"}: ${p.type};`).join("\n")
 function buildComponentBody(name, vrpConfig, props, hasProps, useViraUI) {
     const propsUsage = props.map((p) => `    ${p.name}={props.${p.name}}`).join("\n");
     if (vrpConfig) {
-        return `  const { data, sendEvent, sendUpdate, sendDiff } = useViraState<${vrpConfig.stateType}>('${vrpConfig.channel}', null);
+        // Проверяем, есть ли в channel плейсхолдер {id} или подобный
+        const hasPlaceholder = vrpConfig.channel.includes('{id}') || vrpConfig.channel.includes('${id}');
+        let channelCode = '';
+        if (hasPlaceholder && hasProps) {
+            // Находим prop, который может быть id (clientId, userId, id и т.д.)
+            const idProp = props.find(p => p.name.toLowerCase().includes('id') ||
+                p.name === 'id');
+            if (idProp) {
+                // Заменяем {id} на значение из props
+                const placeholder = vrpConfig.channel.includes('${id}') ? '${id}' : '{id}';
+                const channelTemplate = vrpConfig.channel.replace(placeholder, `\${props.${idProp.name}}`);
+                channelCode = `  // Динамически формируем channel с ${idProp.name} из props
+  const channel = \`${channelTemplate}\`;
+  const { data, sendEvent, sendUpdate, sendDiff } = useViraState<${vrpConfig.stateType}>(channel, null);`;
+            }
+            else {
+                channelCode = `  const { data, sendEvent, sendUpdate, sendDiff } = useViraState<${vrpConfig.stateType}>('${vrpConfig.channel}', null);`;
+            }
+        }
+        else {
+            channelCode = `  const { data, sendEvent, sendUpdate, sendDiff } = useViraState<${vrpConfig.stateType}>('${vrpConfig.channel}', null);`;
+        }
+        return `${channelCode}
 
   // Use data from VRP state
   // Example: const value = data?.field ?? defaultValue;
@@ -841,7 +907,7 @@ function buildComponentBody(name, vrpConfig, props, hasProps, useViraUI) {
   // }, { debounce: 500 });
 
   return createElement('div', { className: '${name.toLowerCase()}' },
-${propsUsage ? propsUsage + ",\n" : ""}    // Add your content here
+    // Add your content here
   );`;
     }
     if (useViraUI) {
@@ -888,7 +954,12 @@ async function generateComponent(name, dir, config) {
 `;
     // Интерфейс состояния VRP
     if (vrpConfig) {
-        componentCode += `export interface ${vrpConfig.stateType} {
+        const typeName = vrpConfig.stateType.replace('State', '');
+        componentCode += `// TODO: Если у вас есть синхронизированные типы из backend, используйте их:
+// import type { ${typeName} } from '../vira-types';
+// export type ${vrpConfig.stateType} = ${typeName};
+
+export interface ${vrpConfig.stateType} {
   // Add your state fields here
   id?: string;
 }
@@ -967,10 +1038,15 @@ async function collectServiceVRPConfig(name, useVRP, interactive) {
  */
 function buildVRPService(name, vrpConfig) {
     const lowerName = name.toLowerCase();
+    // Пытаемся определить имя типа из синхронизированных типов (например, Client вместо ClientState)
+    const typeName = vrpConfig.stateType.replace('State', '');
     return `// ${name} service using Vira Core DI container + VRP
-import { createService, useService } from '@vira-ui/core';
+import { createService, useService, batch } from '@vira-ui/core';
 import { useViraState } from '@vira-ui/react';
 import { v4 as uuid } from 'uuid';
+// TODO: Если у вас есть синхронизированные типы из backend, используйте их:
+// import type { ${typeName} } from '../vira-types';
+// export type ${vrpConfig.stateType} = ${typeName};
 
 export interface ${vrpConfig.stateType} {
   // Add your state fields here
@@ -1000,22 +1076,26 @@ createService('${lowerName}', () => ({
 // Hook for ${name} operations (combines service + VRP state)
 export function use${name}(id?: string) {
   const channel = id ? \`${vrpConfig.channel}:\${id}\` : '${vrpConfig.channel}';
-  const { data, sendEvent, sendUpdate, sendDiff } = id 
+  const vrpState = id 
     ? useViraState<${vrpConfig.stateType}>(channel, null)
     : useVrpList<${vrpConfig.stateType}>(channel);
   const ${lowerName}Service = useService<{ processData: (data: ${vrpConfig.stateType} | null) => any }>('${lowerName}');
 
+  // Извлекаем методы из VRP состояния
+  const { data, sendEvent, sendDiff } = vrpState;
+  const sendUpdate = 'sendUpdate' in vrpState ? vrpState.sendUpdate : undefined;
+
   return {
     data,
     // 🎯 1️⃣ Создание с авто-генерацией UUID на фронте (VRP сразу знает id, не надо ждать бэка)
     create(item: Omit<${vrpConfig.stateType}, 'id' | 'created_at' | 'updated_at'>) {
-      const id = uuid();
+      const itemId = uuid();
       const newItem: ${vrpConfig.stateType} = {
         ...item,
-        id,
+        id: itemId,
         created_at: new Date().toISOString(),
         updated_at: new Date().toISOString(),
-      };
+      } as ${vrpConfig.stateType};
       sendEvent('${lowerName}.created', {
         ...newItem,
         timestamp: new Date().toISOString()
@@ -1039,16 +1119,17 @@ export function use${name}(id?: string) {
     },
     sendEvent,
     sendDiff,
+    sendUpdate,
     // Service methods
     processData() {
-      return ${lowerName}Service.processData(data);
+      // data может быть массивом или объектом, обрабатываем оба случая
+      const singleData = Array.isArray(data) ? null : (data as ${vrpConfig.stateType} | null);
+      return ${lowerName}Service.processData(singleData);
     },
   };
 }
 
 // 🎯 2️⃣ Сервис для bulk actions с VRP (переиспользуемый для любых сущностей)
-// Используем batch() из @vira-ui/core для оптимизации множественных обновлений
-import { batch } from '@vira-ui/core';
 
 createService('${lowerName}Bulk', () => ({
   bulkUpdate(ids: string[], payload: Partial<${vrpConfig.stateType}>, sendEvent: Function) {
@@ -1292,9 +1373,31 @@ describe('${name}Page', () => {
  * Sync TypeScript types from Go structs (scaffold-level parser)
  */
 async function syncTypes(options) {
-    const backendPath = path.resolve(process.cwd(), options.backend);
-    const goSource = await fs.readFile(backendPath, "utf8");
-    const structs = parseGoStructs(goSource);
+    let structs = [];
+    if (options.fromModels) {
+        const modelsDir = path.resolve(process.cwd(), options.models || path.join("backend", "internal", "models"));
+        structs = await parseGoStructsFromDir(modelsDir);
+    }
+    else {
+        const backendPath = path.resolve(process.cwd(), options.backend);
+        const exists = await fs.pathExists(backendPath);
+        if (!exists) {
+            // Friendly fallback: if types.go isn't present (many projects don't need it anymore),
+            // but models exist — generate from models.
+            const modelsDir = path.resolve(process.cwd(), options.models || path.join("backend", "internal", "models"));
+            if (await fs.pathExists(modelsDir)) {
+                structs = await parseGoStructsFromDir(modelsDir);
+            }
+            else {
+                throw new Error(`Go types file not found: ${backendPath}. ` +
+                    `Either create it, or run "vira sync --types --from-models" (and ensure ${modelsDir} exists).`);
+            }
+        }
+        else {
+            const goSource = await fs.readFile(backendPath, "utf8");
+            structs = parseGoStructs(goSource);
+        }
+    }
     const tsContent = renderTsTypes(structs);
     const targets = [
         path.resolve(process.cwd(), options.frontend),
@@ -1306,6 +1409,39 @@ async function syncTypes(options) {
     }
     console.log(chalk_1.default.green(`✓ Synced ${structs.length} type(s) to ${options.frontend} and ${options.ui}`));
 }
+async function parseGoStructsFromDir(modelsDir) {
+    const out = [];
+    const exists = await fs.pathExists(modelsDir);
+    if (!exists) {
+        throw new Error(`Models directory not found: ${modelsDir}`);
+    }
+    const stat = await fs.stat(modelsDir);
+    if (!stat.isDirectory()) {
+        throw new Error(`Models path is not a directory: ${modelsDir}`);
+    }
+    const files = (await fs.readdir(modelsDir))
+        .filter((f) => f.endsWith(".go") && !f.endsWith("_test.go"));
+    for (const file of files) {
+        const full = path.join(modelsDir, file);
+        const src = await fs.readFile(full, "utf8");
+        out.push(...parseGoStructs(src));
+    }
+    // De-dupe by struct name (first wins)
+    const seen = new Set();
+    const deduped = [];
+    for (const s of out) {
+        if (!s?.name)
+            continue;
+        // Only exported types (to avoid internal helpers)
+        if (s.name[0] !== s.name[0].toUpperCase())
+            continue;
+        if (seen.has(s.name))
+            continue;
+        seen.add(s.name);
+        deduped.push(s);
+    }
+    return deduped;
+}
 function parseGoStructs(source) {
     const structs = [];
     const structRegex = /type\s+(\w+)\s+struct\s*\{([^}]*)\}/gm;
@@ -1326,9 +1462,13 @@ function parseGoStructs(source) {
             const fieldName = tokens[0];
             const fieldType = tokens[1];
             let jsonTag;
-            const tagMatch = line.match(/`json:"([^"]+)"/);
+            // json tag can appear anywhere inside the struct tags: `db:"..." json:"..."`
+            const tagMatch = line.match(/json:"([^"]+)"/);
             if (tagMatch) {
-                jsonTag = tagMatch[1].replace(",omitempty", "");
+                jsonTag = tagMatch[1].split(",")[0];
+                if (jsonTag === "-" || jsonTag === "") {
+                    continue; // skip non-exposed fields
+                }
             }
             fields.push({ name: fieldName, type: fieldType, json: jsonTag });
         }
@@ -1444,6 +1584,9 @@ function goTypeToTs(goType) {
 function toCamel(name) {
     if (!name)
         return name;
+    // "ID" -> "id", "URL" -> "url" (common Go acronym fields)
+    if (/^[A-Z0-9]+$/.test(name))
+        return name.toLowerCase();
     return name.charAt(0).toLowerCase() + name.slice(1);
 }
 /**
@@ -1570,16 +1713,463 @@ async function generateMigration(name, dir) {
     const baseName = `${timestamp}_${name}`;
     const targetDir = path.join(process.cwd(), dir);
     await fs.ensureDir(targetDir);
-    const upPath = path.join(targetDir, `${baseName}.up.sql`);
-    const downPath = path.join(targetDir, `${baseName}.down.sql`);
-    const upTemplate = `-- +goose Up
+    // Goose v3 имеет проблему с отдельными .up.sql/.down.sql файлами (дубликат версии)
+    // Используем один файл .sql с обеими директивами (работает надежнее)
+    const migrationPath = path.join(targetDir, `${baseName}.sql`);
+    const migrationTemplate = `-- +goose Up
+-- +goose StatementBegin
 -- TODO: add migration SQL here
-`;
-    const downTemplate = `-- +goose Down
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
 -- TODO: rollback SQL here
+-- +goose StatementEnd
 `;
-    await fs.writeFile(upPath, upTemplate);
-    await fs.writeFile(downPath, downTemplate);
+    await fs.writeFile(migrationPath, migrationTemplate);
+}
+/**
+ * Получить DATABASE_URL из переменных окружения или .env файлов
+ */
+async function getDatabaseUrl() {
+    // Сначала проверяем переменную окружения
+    if (process.env.DATABASE_URL) {
+        return process.env.DATABASE_URL;
+    }
+    // Пытаемся прочитать .env файлы
+    const possibleEnvPaths = [
+        path.join(process.cwd(), ".env"),
+        path.join(process.cwd(), "env"),
+        path.join(process.cwd(), "backend", ".env"),
+        path.join(process.cwd(), ".env.local"),
+    ];
+    for (const envPath of possibleEnvPaths) {
+        if (await fs.pathExists(envPath)) {
+            try {
+                const envContent = await fs.readFile(envPath, "utf8");
+                const lines = envContent.split("\n");
+                for (const line of lines) {
+                    // Пропускаем комментарии и пустые строки
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith("#"))
+                        continue;
+                    // Парсим DATABASE_URL=value
+                    const match = trimmed.match(/^DATABASE_URL\s*=\s*(.+)$/);
+                    if (match) {
+                        // Убираем кавычки если есть
+                        let value = match[1].trim();
+                        if ((value.startsWith('"') && value.endsWith('"')) ||
+                            (value.startsWith("'") && value.endsWith("'"))) {
+                            value = value.slice(1, -1);
+                        }
+                        return value;
+                    }
+                }
+            }
+            catch (error) {
+                // Игнорируем ошибки чтения .env файла
+            }
+        }
+    }
+    // Пытаемся собрать URL из отдельных переменных DB_*
+    const dbHost = process.env.DB_HOST || process.env.POSTGRES_HOST || "localhost";
+    const dbPort = process.env.DB_PORT || process.env.POSTGRES_PORT || "5432";
+    const dbUser = process.env.DB_USER || process.env.POSTGRES_USER || "postgres";
+    const dbPassword = process.env.DB_PASSWORD || process.env.POSTGRES_PASSWORD || "";
+    const dbName = process.env.DB_NAME || process.env.POSTGRES_DB || process.env.DB_DATABASE || "";
+    if (dbName) {
+        return `postgres://${dbUser}${dbPassword ? `:${dbPassword}` : ""}@${dbHost}:${dbPort}/${dbName}?sslmode=disable`;
+    }
+    return undefined;
+}
+/**
+ * Выполнение миграций через goose
+ */
+async function runMigrations(migrationsDir, dbUrl, driver, direction) {
+    const { execSync } = require("child_process");
+    const migrationsPath = path.resolve(process.cwd(), migrationsDir);
+    // Проверяем наличие директории миграций
+    if (!(await fs.pathExists(migrationsPath))) {
+        console.error(chalk_1.default.red(`✗ Migrations directory not found: ${migrationsPath}`));
+        console.log(chalk_1.default.yellow(`   Create migrations with: npx vira make migration <name>`));
+        process.exit(1);
+    }
+    // Получаем URL базы данных (проверяем .env файлы)
+    const databaseUrl = dbUrl || await getDatabaseUrl();
+    if (!databaseUrl) {
+        console.error(chalk_1.default.red("✗ Database URL not provided"));
+        console.log(chalk_1.default.yellow("   Use --db-url option, set DATABASE_URL environment variable, or create .env file"));
+        console.log(chalk_1.default.yellow("   Example: DATABASE_URL=postgres://user:pass@localhost/dbname?sslmode=disable"));
+        console.log(chalk_1.default.yellow("   Or create .env in project root with: DATABASE_URL=..."));
+        process.exit(1);
+    }
+    // Проверяем наличие goose (кроссплатформенная проверка)
+    const isWindows = process.platform === "win32";
+    const checkCommand = isWindows ? "where goose" : "which goose";
+    let gooseInstalled = false;
+    try {
+        execSync(checkCommand, { stdio: "ignore" });
+        gooseInstalled = true;
+    }
+    catch {
+        // goose не найден
+    }
+    if (!gooseInstalled) {
+        console.log(chalk_1.default.blue("goose not found. Installing..."));
+        console.log(chalk_1.default.gray("   This will download goose and its dependencies (this is normal)"));
+        try {
+            // Скрываем вывод загрузки зависимостей, показываем только прогресс
+            execSync("go install github.com/pressly/goose/v3/cmd/goose@latest", {
+                stdio: "inherit",
+                env: { ...process.env, GOFLAGS: "-mod=mod" }
+            });
+            console.log(chalk_1.default.green("✓ goose installed successfully"));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red("✗ Failed to install goose"));
+            console.log(chalk_1.default.yellow("   Install manually: go install github.com/pressly/goose/v3/cmd/goose@latest"));
+            console.log(chalk_1.default.yellow("   Or download from: https://github.com/pressly/goose/releases"));
+            process.exit(1);
+        }
+    }
+    // Выполняем миграции
+    try {
+        const command = direction === "up" ? "up" : "down";
+        console.log(chalk_1.default.blue(`Running migrations ${direction}...`));
+        // Используем переменные окружения для goose (более надежно на Windows)
+        const env = {
+            ...process.env,
+            GOOSE_DRIVER: driver,
+            GOOSE_DBSTRING: databaseUrl,
+        };
+        execSync(`goose -dir "${migrationsPath}" ${command}`, {
+            stdio: "inherit",
+            cwd: process.cwd(),
+            env: env
+        });
+        console.log(chalk_1.default.green(`✓ Migrations ${direction} completed successfully`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`✗ Migration failed: ${error.message}`));
+        process.exit(1);
+    }
+}
+/**
+ * Показать статус миграций
+ */
+async function showMigrationStatus(migrationsDir, dbUrl, driver) {
+    const { execSync } = require("child_process");
+    const migrationsPath = path.resolve(process.cwd(), migrationsDir);
+    if (!(await fs.pathExists(migrationsPath))) {
+        console.error(chalk_1.default.red(`✗ Migrations directory not found: ${migrationsPath}`));
+        process.exit(1);
+    }
+    const databaseUrl = dbUrl || await getDatabaseUrl();
+    if (!databaseUrl) {
+        console.error(chalk_1.default.red("✗ Database URL not provided"));
+        console.log(chalk_1.default.yellow("   Use --db-url option, set DATABASE_URL environment variable, or create .env file"));
+        process.exit(1);
+    }
+    try {
+        console.log(chalk_1.default.blue("Migration status:"));
+        // Используем переменные окружения для goose (более надежно на Windows)
+        const env = {
+            ...process.env,
+            GOOSE_DRIVER: driver,
+            GOOSE_DBSTRING: databaseUrl,
+        };
+        execSync(`goose -dir "${migrationsPath}" status`, {
+            stdio: "inherit",
+            cwd: process.cwd(),
+            env: env
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`✗ Failed to get migration status: ${error.message}`));
+        process.exit(1);
+    }
+}
+/**
+ * Выполнение сидеров (seeds)
+ */
+async function runSeeds(seedsDir, dbUrl, driver) {
+    const { execSync } = require("child_process");
+    const seedsPath = path.resolve(process.cwd(), seedsDir);
+    // Проверяем наличие директории сидеров
+    if (!(await fs.pathExists(seedsPath))) {
+        console.error(chalk_1.default.red(`✗ Seeds directory not found: ${seedsPath}`));
+        console.log(chalk_1.default.yellow(`   Create seeds directory and add SQL files`));
+        process.exit(1);
+    }
+    // Получаем URL базы данных
+    const databaseUrl = dbUrl || await getDatabaseUrl();
+    if (!databaseUrl) {
+        console.error(chalk_1.default.red("✗ Database URL not provided"));
+        console.log(chalk_1.default.yellow("   Use --db-url option, set DATABASE_URL environment variable, or create .env file"));
+        process.exit(1);
+    }
+    // Получаем список SQL файлов из папки seeds
+    const files = await fs.readdir(seedsPath);
+    const sqlFiles = files
+        .filter((f) => f.endsWith(".sql"))
+        .sort(); // Сортируем по имени для последовательного выполнения
+    if (sqlFiles.length === 0) {
+        console.log(chalk_1.default.yellow(`⚠ No SQL files found in ${seedsPath}`));
+        return;
+    }
+    console.log(chalk_1.default.blue(`Found ${sqlFiles.length} seed file(s):`));
+    sqlFiles.forEach((file) => {
+        console.log(chalk_1.default.gray(`  - ${file}`));
+    });
+    // Выполняем каждый SQL файл
+    try {
+        console.log(chalk_1.default.blue(`\nRunning seeds...`));
+        if (driver === "postgres") {
+            // Для PostgreSQL используем psql
+            const isWindows = process.platform === "win32";
+            // Парсим DATABASE_URL используя встроенный URL класс
+            let parsedUrl;
+            try {
+                parsedUrl = new URL(databaseUrl);
+            }
+            catch (error) {
+                console.error(chalk_1.default.red("✗ Invalid DATABASE_URL format for PostgreSQL"));
+                console.log(chalk_1.default.yellow("   Expected format: postgres://user:password@host:port/dbname"));
+                console.log(chalk_1.default.gray(`   Error: ${error instanceof Error ? error.message : String(error)}`));
+                process.exit(1);
+            }
+            // Проверяем протокол
+            if (parsedUrl.protocol !== "postgres:" && parsedUrl.protocol !== "postgresql:") {
+                console.error(chalk_1.default.red("✗ Invalid database protocol"));
+                console.log(chalk_1.default.yellow("   Expected protocol: postgres:// or postgresql://"));
+                process.exit(1);
+            }
+            const user = parsedUrl.username || "postgres";
+            const password = parsedUrl.password || "";
+            const host = parsedUrl.hostname || "localhost";
+            const port = parsedUrl.port || "5432";
+            const dbname = parsedUrl.pathname ? parsedUrl.pathname.slice(1) : ""; // Убираем ведущий /
+            if (!dbname) {
+                console.error(chalk_1.default.red("✗ Database name not specified in DATABASE_URL"));
+                process.exit(1);
+            }
+            // Проверяем наличие psql локально
+            let useDocker = false;
+            let dockerContainer = "";
+            try {
+                execSync(isWindows ? "where psql" : "which psql", { stdio: "ignore" });
+            }
+            catch {
+                // psql не найден локально, пробуем Docker
+                useDocker = true;
+                console.log(chalk_1.default.blue("  psql not found locally, trying Docker..."));
+                // Пробуем найти контейнер PostgreSQL
+                try {
+                    // Список запущенных контейнеров
+                    const containersOutput = execSync("docker ps --format {{.Names}}", { encoding: "utf8" });
+                    const containers = containersOutput.trim().split("\n")
+                        .filter((c) => c.trim())
+                        .map((c) => c.trim().replace(/['"]/g, "")); // Убираем кавычки
+                    // Ищем контейнер с postgres в имени
+                    const postgresContainer = containers.find((c) => c.toLowerCase().includes("postgres") ||
+                        c.toLowerCase().includes("db") ||
+                        c.toLowerCase().includes("database"));
+                    if (postgresContainer) {
+                        dockerContainer = postgresContainer;
+                        console.log(chalk_1.default.gray(`  Found Docker container: ${dockerContainer}`));
+                        // Проверяем, что контейнер действительно запущен
+                        try {
+                            const checkOutput = execSync(`docker ps --filter "name=^${dockerContainer}$" --format {{.Names}}`, { encoding: "utf8", stdio: "pipe" });
+                            if (!checkOutput.trim()) {
+                                console.error(chalk_1.default.red(`✗ Container ${dockerContainer} is not running`));
+                                process.exit(1);
+                            }
+                        }
+                        catch {
+                            console.error(chalk_1.default.red(`✗ Container ${dockerContainer} is not running`));
+                            process.exit(1);
+                        }
+                    }
+                    else {
+                        // Пробуем стандартные имена
+                        const standardNames = ["postgres", "postgresql", "db", "database", "vira-db", "vira_db"];
+                        for (const name of standardNames) {
+                            try {
+                                const checkOutput = execSync(`docker ps --filter "name=^${name}$" --format {{.Names}}`, { encoding: "utf8", stdio: "pipe" });
+                                if (checkOutput.trim()) {
+                                    dockerContainer = name;
+                                    console.log(chalk_1.default.gray(`  Using Docker container: ${dockerContainer}`));
+                                    break;
+                                }
+                            }
+                            catch {
+                                // Продолжаем поиск
+                            }
+                        }
+                    }
+                    if (!dockerContainer) {
+                        console.error(chalk_1.default.red("✗ psql not found and no PostgreSQL Docker container detected"));
+                        console.log(chalk_1.default.yellow("   Please install PostgreSQL client tools or ensure Docker container is running"));
+                        console.log(chalk_1.default.yellow("   Container name should contain 'postgres', 'db', or 'database'"));
+                        process.exit(1);
+                    }
+                }
+                catch (dockerError) {
+                    console.error(chalk_1.default.red("✗ Docker not available or PostgreSQL container not found"));
+                    console.log(chalk_1.default.yellow("   Please install PostgreSQL client tools (psql) or ensure Docker is running"));
+                    process.exit(1);
+                }
+            }
+            // Устанавливаем переменную окружения PGPASSWORD для psql
+            const env = {
+                ...process.env,
+                PGPASSWORD: password,
+            };
+            // Функция для выполнения SQL запроса
+            const executeSQL = async (sql) => {
+                const tempFile = path.join(seedsPath, `.temp_${Date.now()}.sql`);
+                await fs.writeFile(tempFile, sql);
+                try {
+                    if (useDocker && dockerContainer) {
+                        const containerPath = `/tmp/temp_${Date.now()}.sql`;
+                        execSync(`docker cp "${tempFile}" "${dockerContainer}":${containerPath}`, { stdio: "ignore" });
+                        const escapedPassword = password.replace(/'/g, "'\\''");
+                        const output = execSync(`docker exec -e PGPASSWORD='${escapedPassword}' "${dockerContainer}" psql -U ${user} -d ${dbname} -t -A -f ${containerPath}`, { encoding: "utf8", stdio: "pipe" });
+                        execSync(`docker exec "${dockerContainer}" rm ${containerPath}`, { stdio: "ignore" });
+                        return output.trim();
+                    }
+                    else {
+                        const output = execSync(`psql -h ${host} -p ${port} -U ${user} -d ${dbname} -t -A -f "${tempFile}"`, { encoding: "utf8", stdio: "pipe", env: env });
+                        return output.trim();
+                    }
+                }
+                finally {
+                    await fs.remove(tempFile);
+                }
+            };
+            // Получаем список уже выполненных seed-файлов
+            let executedSeeds = new Set();
+            try {
+                const checkTableSQL = `
+          SELECT EXISTS (
+            SELECT FROM information_schema.tables 
+            WHERE table_schema = 'public' 
+            AND table_name = 'seed_history'
+          );
+        `;
+                const tableExists = await executeSQL(checkTableSQL);
+                if (tableExists === "t") {
+                    const getExecutedSQL = `SELECT seed_file FROM seed_history WHERE success = true;`;
+                    const executedOutput = await executeSQL(getExecutedSQL);
+                    if (executedOutput) {
+                        executedSeeds = new Set(executedOutput.split("\n").filter((f) => f.trim()));
+                    }
+                }
+            }
+            catch (error) {
+                // Игнорируем ошибки при проверке - возможно таблица еще не создана
+                console.log(chalk_1.default.yellow("  ⚠ Could not check seed history, will execute all seeds"));
+            }
+            // Фильтруем уже выполненные seed-файлы
+            const pendingSeeds = sqlFiles.filter((file) => !executedSeeds.has(file));
+            if (pendingSeeds.length === 0) {
+                console.log(chalk_1.default.green(`\n✓ All seeds have already been executed`));
+                return;
+            }
+            if (pendingSeeds.length < sqlFiles.length) {
+                console.log(chalk_1.default.blue(`\n  ${sqlFiles.length - pendingSeeds.length} seed(s) already executed, ${pendingSeeds.length} pending`));
+            }
+            for (const file of pendingSeeds) {
+                const filePath = path.join(seedsPath, file);
+                const startTime = Date.now();
+                console.log(chalk_1.default.blue(`  Running ${file}...`));
+                let success = false;
+                let errorMsg = "";
+                try {
+                    if (useDocker && dockerContainer) {
+                        // Копируем файл в контейнер и выполняем
+                        const fileName = path.basename(filePath);
+                        const containerPath = `/tmp/${fileName}`;
+                        // Копируем файл в контейнер (используем кавычки для имени контейнера на случай пробелов)
+                        execSync(`docker cp "${filePath}" "${dockerContainer}":${containerPath}`, { stdio: "inherit" });
+                        // Выполняем SQL в контейнере (экранируем пароль и используем кавычки)
+                        const escapedPassword = password.replace(/'/g, "'\\''");
+                        execSync(`docker exec -e PGPASSWORD='${escapedPassword}' "${dockerContainer}" psql -U ${user} -d ${dbname} -f ${containerPath}`, {
+                            stdio: "inherit",
+                            cwd: process.cwd(),
+                        });
+                        // Удаляем временный файл из контейнера
+                        try {
+                            execSync(`docker exec "${dockerContainer}" rm ${containerPath}`, { stdio: "ignore" });
+                        }
+                        catch {
+                            // Игнорируем ошибки удаления
+                        }
+                    }
+                    else {
+                        // Используем локальный psql
+                        execSync(`psql -h ${host} -p ${port} -U ${user} -d ${dbname} -f "${filePath}"`, {
+                            stdio: "inherit",
+                            cwd: process.cwd(),
+                            env: env,
+                        });
+                    }
+                    const executionTime = Date.now() - startTime;
+                    success = true;
+                    console.log(chalk_1.default.green(`  ✓ ${file} completed (${executionTime}ms)`));
+                    // Записываем успешное выполнение в seed_history
+                    try {
+                        const insertSQL = `
+              INSERT INTO seed_history (seed_file, execution_time_ms, success)
+              VALUES ('${file.replace(/'/g, "''")}', ${executionTime}, true)
+              ON CONFLICT (seed_file) DO UPDATE SET
+                executed_at = CURRENT_TIMESTAMP,
+                execution_time_ms = ${executionTime},
+                success = true,
+                error_message = NULL;
+            `;
+                        await executeSQL(insertSQL);
+                    }
+                    catch (historyError) {
+                        // Игнорируем ошибки записи истории
+                        console.log(chalk_1.default.yellow(`  ⚠ Could not record seed history: ${historyError instanceof Error ? historyError.message : String(historyError)}`));
+                    }
+                }
+                catch (error) {
+                    const executionTime = Date.now() - startTime;
+                    errorMsg = error.message || String(error);
+                    console.error(chalk_1.default.red(`  ✗ ${file} failed: ${errorMsg}`));
+                    // Записываем неудачное выполнение в seed_history
+                    try {
+                        const insertSQL = `
+              INSERT INTO seed_history (seed_file, execution_time_ms, success, error_message)
+              VALUES ('${file.replace(/'/g, "''")}', ${executionTime}, false, '${errorMsg.replace(/'/g, "''")}')
+              ON CONFLICT (seed_file) DO UPDATE SET
+                executed_at = CURRENT_TIMESTAMP,
+                execution_time_ms = ${executionTime},
+                success = false,
+                error_message = '${errorMsg.replace(/'/g, "''")}';
+            `;
+                        await executeSQL(insertSQL);
+                    }
+                    catch (historyError) {
+                        // Игнорируем ошибки записи истории
+                    }
+                    // Продолжаем выполнение остальных файлов
+                }
+            }
+        }
+        else {
+            // Для других драйверов можно добавить поддержку позже
+            console.error(chalk_1.default.red(`✗ Seeds are currently only supported for PostgreSQL`));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.green(`\n✓ Seeds completed successfully`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`✗ Seeds failed: ${error.message}`));
+        process.exit(1);
+    }
 }
 async function generateEventHandler(name, dir) {
     const targetDir = path.join(process.cwd(), dir);
@@ -1637,12 +2227,20 @@ async function generateCRUDHandler(name, dir, modelName) {
     // Попытка определить модуль из go.mod
     let modulePath = "your-project/backend";
     try {
-        const goModPath = path.join(process.cwd(), dir, "..", "..", "go.mod");
-        if (await fs.pathExists(goModPath)) {
-            const goModContent = await fs.readFile(goModPath, "utf8");
-            const moduleMatch = goModContent.match(/^module\\s+(.+)$/m);
-            if (moduleMatch) {
-                modulePath = moduleMatch[1];
+        // Ищем go.mod в разных возможных местах
+        const possiblePaths = [
+            path.join(process.cwd(), "go.mod"), // корень проекта
+            path.join(process.cwd(), dir, "..", "..", "go.mod"), // backend/../go.mod
+            path.join(process.cwd(), "backend", "go.mod"), // backend/go.mod
+        ];
+        for (const goModPath of possiblePaths) {
+            if (await fs.pathExists(goModPath)) {
+                const goModContent = await fs.readFile(goModPath, "utf8");
+                const moduleMatch = goModContent.match(/^module\s+(.+)$/m);
+                if (moduleMatch) {
+                    modulePath = moduleMatch[1];
+                    break;
+                }
             }
         }
     }
@@ -1814,13 +2412,13 @@ func Create${handlerName}(w http.ResponseWriter, r *http.Request) {
   // }
   
   // 🎯 Production-ready: Log event for audit trail
-  event := ${handlerName}Event{
-    ID:        uuid.New().String(),
-    Type:      "created",
-    EntityID:  input.ID,
-    NewValue:  &input,
-    Timestamp: time.Now(),
-  }
+  // event := ${handlerName}Event{
+  //   ID:        uuid.New().String(),
+  //   Type:      "created",
+  //   EntityID:  input.ID,
+  //   NewValue:  &input,
+  //   Timestamp: time.Now(),
+  // }
   // logEvent(event) // Implement event logging to client_events table
   
   // 🎯 Production-ready: Invalidate cache
@@ -1892,7 +2490,7 @@ func Update${handlerName}(w http.ResponseWriter, r *http.Request) {
 // Delete${handlerName} handles DELETE /${safeName}/{id}
 func Delete${handlerName}(w http.ResponseWriter, r *http.Request) {
   vars := mux.Vars(r)
-  id := vars["id"]
+  id := vars["id"] // id will be used when implementing DB delete and event logging
   
   // 🎯 Production-ready: Get value for event logging
   // oldValue, _ := db.Get${handlerName}(id)