@vira-ui/cli 1.1.2 → 2.0.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.2");
+    .version("1.2.0");
 const SUPPORTED_TEMPLATES = ["frontend", "fullstack", "kanban"];
 /**
  * Инициализация проекта в текущей директории
@@ -325,6 +325,15 @@ dbCommand
     .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")
@@ -466,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)
@@ -1362,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),
@@ -1376,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;
@@ -1396,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 });
         }
@@ -1514,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);
 }
 /**
@@ -1640,16 +1713,74 @@ 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
@@ -1663,26 +1794,41 @@ async function runMigrations(migrationsDir, dbUrl, driver, direction) {
         console.log(chalk_1.default.yellow(`   Create migrations with: npx vira make migration <name>`));
         process.exit(1);
     }
-    // Получаем URL базы данных
-    const databaseUrl = dbUrl || process.env.DATABASE_URL;
+    // Получаем 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 or set DATABASE_URL environment variable"));
+        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
+    // Проверяем наличие goose (кроссплатформенная проверка)
+    const isWindows = process.platform === "win32";
+    const checkCommand = isWindows ? "where goose" : "which goose";
+    let gooseInstalled = false;
     try {
-        execSync("which goose", { stdio: "ignore" });
+        execSync(checkCommand, { stdio: "ignore" });
+        gooseInstalled = true;
     }
     catch {
-        console.log(chalk_1.default.blue("Installing goose..."));
+        // 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" });
+            // Скрываем вывод загрузки зависимостей, показываем только прогресс
+            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);
         }
     }
@@ -1690,7 +1836,17 @@ async function runMigrations(migrationsDir, dbUrl, driver, direction) {
     try {
         const command = direction === "up" ? "up" : "down";
         console.log(chalk_1.default.blue(`Running migrations ${direction}...`));
-        execSync(`goose -dir "${migrationsPath}" ${driver} "${databaseUrl}" ${command}`, { stdio: "inherit", cwd: process.cwd() });
+        // Используем переменные окружения для 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) {
@@ -1708,21 +1864,313 @@ async function showMigrationStatus(migrationsDir, dbUrl, driver) {
         console.error(chalk_1.default.red(`✗ Migrations directory not found: ${migrationsPath}`));
         process.exit(1);
     }
-    const databaseUrl = dbUrl || process.env.DATABASE_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 or set DATABASE_URL environment variable"));
+        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:"));
-        execSync(`goose -dir "${migrationsPath}" ${driver} "${databaseUrl}" status`, { stdio: "inherit", cwd: process.cwd() });
+        // Используем переменные окружения для 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);
     await fs.ensureDir(targetDir);

package/dist/react/envExample.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.envExample = void 0;
-exports.envExample = `# Frontend environment example
-VITE_API_URL=http://localhost:8080
-VITE_AUTH_TOKEN=
+exports.envExample = `# Frontend environment example
+VITE_API_URL=http://localhost:8080
+VITE_AUTH_TOKEN=
 `;

package/dist/react/envLocal.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.envLocal = void 0;
-exports.envLocal = `VITE_API_URL=http://localhost:8080
+exports.envLocal = `VITE_API_URL=http://localhost:8080
 `;

package/dist/react/indexCss.js

@@ -2,21 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexCss = void 0;
 // src/index.css
-exports.indexCss = `* {
-    margin: 0;
-    padding: 0;
-    box-sizing: border-box;
-  }
-  
-  body {
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
-      'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
-      sans-serif;
-    -webkit-font-smoothing: antialiased;
-    -moz-osx-font-smoothing: grayscale;
-  }
-  
-  #root {
-    min-height: 100vh;
-  }
+exports.indexCss = `* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+  }
+  
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+      'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+      sans-serif;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  
+  #root {
+    min-height: 100vh;
+  }
   `;