добавь сохранения после каждого изменения данных в  базе 
// app.js
const express = require('express');
const bodyParser = require('body-parser');
const fs = require('fs');
const path = require('path');
const { GPU } = require('gpu.js');

// Инициализация GPU.js
const gpu = new GPU();

// Класс Table для управления таблицами
class Table {
  constructor(name, schema) {
    this.name = name;
    this.schema = schema; // Объект, например: { id: 'number', name: 'string' }
    // Инициализация колонок
    this.columns = {};
    for (let field in schema) {
      if (schema[field] === 'number') {
        this.columns[field] = []; // Для чисел можно использовать TypedArray, если необходимо
      } else {
        this.columns[field] = [];
      }
    }
  }

  // Метод для вставки записи
  insert(record) {
    if (record.id === undefined || record.id === null) {
      throw new Error('Поле "id" обязательно для вставки записи.');
    }
    const id = record.id;
    const ids = this.columns['id'];
    if (ids.includes(id)) {
      throw new Error(`Запись с id=${id} уже существует.`);
    }
    for (let field in this.schema) {
      this.columns[field].push(record[field] !== undefined ? record[field] : (this.schema[field] === 'number' ? 0 : ''));
    }
  }

  // Метод для удаления записи по id
  delete(id) {
    const ids = this.columns['id'];
    const index = ids.indexOf(id);
    if (index !== -1) {
      for (let field in this.columns) {
        this.columns[field].splice(index, 1);
      }
      return true;
    }
    return false;
  }

  // Метод для обновления записи по id
  update(id, newRecord) {
    const ids = this.columns['id'];
    const index = ids.indexOf(id);
    if (index !== -1) {
      for (let field in newRecord) {
        if (this.schema[field]) {
          this.columns[field][index] = newRecord[field];
        }
      }
      return true;
    }
    return false;
  }

  // Метод для получения записи по id с использованием GPU
  getGPU(id) {
    // Преобразуем колонки в массивы чисел или строк
    const recordLength = this.columns['id'].length;
    const ids = this.columns['id'];

    // Создаем TypedArray для id, если они числа
    let idArray;
    if (this.schema['id'] === 'number') {
      idArray = new Float32Array(ids);
    } else {
      // Для строк GPU.js не поддерживает, поэтому ограничимся числовым id
      throw new Error('GPU-поиск поддерживается только для числовых id.');
    }

    // Создаем GPU Kernel для поиска индекса
    const findIndexGPU = gpu.createKernel(function(idArray, targetId) {
      let index = -1;
      for (let i = 0; i < this.constants.size; i++) {
        if (idArray[i] === targetId) {
          index = i;
          break;
        }
      }
      return index;
    })
    .setOutput([1])
    .setConstants({ size: recordLength });

    const index = findIndexGPU(idArray, id)[0];

    if (index === -1) return null;

    // Получение всей записи
    const record = {};
    for (let field in this.columns) {
      record[field] = this.columns[field][index];
    }
    return record;
  }

  get(id) {
    return this.getGPU(id);
    // Или использовать CPU метод:
    // return this.getCPU(id);
  }

  getAll() {
    // Преобразование колонночного хранения в массив записей
    const recordLength = this.columns['id'].length;
    const records = [];
    for (let i = 0; i < recordLength; i++) {
      const record = {};
      for (let field in this.columns) {
        record[field] = this.columns[field][i];
      }
      records.push(record);
    }
    return records;
  }

  // Использование GPU для получения записи по id
  getCPU(id) {
    const index = this.columns['id'].indexOf(id);
    if (index === -1) return null;
    const record = {};
    for (let field in this.columns) {
      record[field] = this.columns[field][index];
    }
    return record;
  }

  // Добавление новой колонки
  addColumn(columnName, columnType) {
    if (this.schema[columnName]) {
      throw new Error(`Колонка "${columnName}" уже существует.`);
    }
    if (!['number', 'string'].includes(columnType.toLowerCase())) {
      throw new Error('Поддерживаются только типы "number" и "string".');
    }
    this.schema[columnName] = columnType.toLowerCase();
    // Инициализируем новую колонку
    this.columns[columnName] = this.columns['id'].map(() => (columnType.toLowerCase() === 'number' ? 0 : ''));
  }

  // Удаление колонки
  deleteColumn(columnName) {
    if (!this.schema[columnName]) {
      throw new Error(`Колонка "${columnName}" не найдена.`);
    }
    if (columnName === 'id') {
      throw new Error('Невозможно удалить обязательную колонку "id".');
    }
    delete this.schema[columnName];
    delete this.columns[columnName];
  }
}

// Класс Database остается без изменений
class Database {
  constructor() {
    this.tables = new Map();
  }

  createTable(tableName, schema) {
    if (this.tables.has(tableName)) {
      throw new Error(`Таблица "${tableName}" уже существует.`);
    }
    const table = new Table(tableName, schema);
    this.tables.set(tableName, table);
  }

  dropTable(tableName) {
    if (this.tables.delete(tableName)) {
      return true;
    }
    return false;
  }

  insert(tableName, record) {
    const table = this.tables.get(tableName);
    if (!table) {
      throw new Error(`Таблица "${tableName}" не найдена.`);
    }
    table.insert(record);
  }

  delete(tableName, id) {
    const table = this.tables.get(tableName);
    if (!table) {
      throw new Error(`Таблица "${tableName}" не найдена.`);
    }
    return table.delete(id);
  }

  update(tableName, id, newRecord) {
    const table = this.tables.get(tableName);
    if (!table) {
      throw new Error(`Таблица "${tableName}" не найдена.`);
    }
    return table.update(id, newRecord);
  }

  get(tableName, id) {
    const table = this.tables.get(tableName);
    if (!table) {
      throw new Error(`Таблица "${tableName}" не найдена.`);
    }
    // Использование GPU для получения записи
    return table.get(id);
    // Или использовать обычный метод
    // return table.get(id);
  }

  getAll(tableName) {
    const table = this.tables.get(tableName);
    if (!table) {
      throw new Error(`Таблица "${tableName}" не найдена.`);
    }
    return table.getAll();
  }

  getTables() {
    return Array.from(this.tables.keys());
  }

  getTableSchema(tableName) {
    const table = this.tables.get(tableName);
    if (!table) {
      throw new Error(`Таблица "${tableName}" не найдена.`);
    }
    return table.schema;
  }

  addColumn(tableName, columnName, columnType) {
    const table = this.tables.get(tableName);
    if (!table) {
      throw new Error(`Таблица "${tableName}" не найдена.`);
    }
    table.addColumn(columnName, columnType);
  }

  deleteColumn(tableName, columnName) {
    const table = this.tables.get(tableName);
    if (!table) {
      throw new Error(`Таблица "${tableName}" не найдена.`);
    }
    table.deleteColumn(columnName);
  }

  // Сохранение базы данных в файл
  saveToFile(filePath) {
    const data = {};
    this.tables.forEach((table, name) => {
      data[name] = {
        schema: table.schema,
        columns: table.columns
      };
    });
    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
    console.log(`Данные сохранены в ${filePath}`);
  }

  // Загрузка базы данных из файла
  loadFromFile(filePath) {
    if (fs.existsSync(filePath)) {
      const rawData = fs.readFileSync(filePath, 'utf8');
      const data = JSON.parse(rawData);
      for (const tableName in data) {
        const tableData = data[tableName];
        const table = new Table(tableName, tableData.schema);
        for (let field in tableData.columns) {
          table.columns[field] = tableData.columns[field];
        }
        this.tables.set(tableName, table);
      }
      console.log(`Данные загружены из ${filePath}`);
    } else {
      console.log(`Файл ${filePath} не найден. Начинается с пустой базы данных.`);
    }
  }
}

// Инициализация приложения
const app = express();
const PORT = 3000;
const DATA_FILE = path.join(__dirname, 'database.json');

// Инициализация базы данных
const db = new Database();
db.loadFromFile(DATA_FILE);

// Настройка промежуточного ПО
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static(path.join(__dirname, 'public')));

// Функция для рендеринга HTML страниц
function renderPage(res, title, content) {
  const html = `
  <!DOCTYPE html>
  <html lang="ru">
  <head>
    <meta charset="UTF-8">
    <title>${title}</title>
    <!-- Bootstrap CSS -->
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
    <style>
      body {
        padding-top: 70px;
      }
      .table-actions {
        display: flex;
        gap: 5px;
      }
    </style>
  </head>
  <body>
    <nav class="navbar navbar-expand-lg navbar-dark bg-dark fixed-top">
      <a class="navbar-brand" href="/">Custom DB Manager</a>
      <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNav" 
              aria-controls="navbarNav" aria-expanded="false" aria-label="Toggle navigation">
        <span class="navbar-toggler-icon"></span>
      </button>
      <div class="collapse navbar-collapse" id="navbarNav">
        <ul class="navbar-nav mr-auto">
          <li class="nav-item ${title === 'Список Таблиц' ? 'active' : ''}">
            <a class="nav-link" href="/">Таблицы</a>
          </li>
          <li class="nav-item ${title === 'Создать Таблицу' ? 'active' : ''}">
            <a class="nav-link" href="/create-table">Создать Таблицу</a>
          </li>
        </ul>
      </div>
    </nav>
    <div class="container mt-4">
      ${content}
    </div>
    <!-- Bootstrap JS и зависимости -->
    <script src="https://code.jquery.com/jquery-3.5.1.slim.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.1/dist/umd/popper.min.js"></script>
    <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js"></script>
  </body>
  </html>
  `;
  res.send(html);
}

// Главная страница - список таблиц
app.get('/', (req, res) => {
  const tables = db.getTables();
  let content = `<h1>Список Таблиц</h1>`;
  if (tables.length === 0) {
    content += `<div class="alert alert-info">Нет созданных таблиц. Создайте первую таблицу <a href="/create-table">здесь</a>.</div>`;
  } else {
    content += `
    <table class="table table-bordered table-hover">
      <thead class="thead-dark">
        <tr>
          <th>Название Таблицы</th>
          <th>Действия</th>
        </tr>
      </thead>
      <tbody>
    `;
    tables.forEach(table => {
      content += `
        <tr>
          <td><a href="/table/${encodeURIComponent(table)}">${table}</a></td>
          <td>
            <div class="table-actions">
              <a href="/table/${encodeURIComponent(table)}/manage-schema" class="btn btn-secondary btn-sm">Управление Структурой</a>
              <form action="/drop-table/${encodeURIComponent(table)}" method="POST" onsubmit="return confirm('Вы уверены, что хотите удалить таблицу ${table}?');" class="mb-0">
                <button type="submit" class="btn btn-danger btn-sm">Удалить</button>
              </form>
            </div>
          </td>
        </tr>
      `;
    });
    content += `
      </tbody>
    </table>
    `;
  }
  renderPage(res, 'Список Таблиц', content);
});

// Страница создания новой таблицы
app.get('/create-table', (req, res) => {
  const content = `
    <h1>Создать Новую Таблицу</h1>
    <form action="/create-table" method="POST">
      <div class="form-group">
        <label for="tableName">Название Таблицы</label>
        <input type="text" class="form-control" id="tableName" name="tableName" placeholder="Введите название таблицы" required>
      </div>
      <div class="form-group">
        <label for="fields">Поля (формат: имя:тип)</label>
        <div id="fields-container">
          <div class="input-group mb-2">
            <input type="text" class="form-control" name="fields" placeholder="Например: id:number" required>
            <div class="input-group-append">
              <button type="button" class="btn btn-outline-secondary add-field">+</button>
            </div>
          </div>
        </div>
        <small class="form-text text-muted">Пример: id:number, name:string, age:number</small>
      </div>
      <button type="submit" class="btn btn-primary">Создать Таблицу</button>
      <a href="/" class="btn btn-secondary">Отмена</a>
    </form>

    <script>
      document.addEventListener('DOMContentLoaded', function() {
        const addFieldButtons = document.querySelectorAll('.add-field');
        addFieldButtons.forEach(button => {
          button.addEventListener('click', function() {
            const fieldsContainer = document.getElementById('fields-container');
            const newField = document.createElement('div');
            newField.className = 'input-group mb-2';
            newField.innerHTML = \`
              <input type="text" class="form-control" name="fields" placeholder="Например: name:string" required>
              <div class="input-group-append">
                <button type="button" class="btn btn-outline-danger remove-field">&times;</button>
              </div>
            \`;
            fieldsContainer.appendChild(newField);
          });
        });

        document.getElementById('fields-container').addEventListener('click', function(e) {
          if (e.target && e.target.classList.contains('remove-field')) {
            e.target.closest('.input-group').remove();
          }
        });
      });
    </script>
  `;
  renderPage(res, 'Создать Таблицу', content);
});

// Обработка создания новой таблицы
app.post('/create-table', (req, res) => {
  const { tableName } = req.body;
  // Поля приходят как массив, если добавлено несколько полей
  let fields = req.body.fields;
  if (!Array.isArray(fields)) {
    fields = [fields];
  }
  try {
    // Парсинг полей (например, "id:number", "name:string")
    const schema = {};
    fields.forEach(field => {
      const [name, type] = field.trim().split(':');
      if (!name || !type) {
        throw new Error('Некорректный формат полей. Используйте формат "имя:тип".');
      }
      if (!['number', 'string'].includes(type.toLowerCase())) {
        throw new Error('Поддерживаются только типы "number" и "string".');
      }
      schema[name] = type.toLowerCase();
    });
    if (!schema.id) {
      throw new Error('Необходимо указать поле "id:number" в качестве уникального идентификатора.');
    }
    db.createTable(tableName, schema);
    res.redirect('/');
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/create-table" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Страница управления структурой таблицы
app.get('/table/:tableName/manage-schema', (req, res) => {
  const tableName = req.params.tableName;
  try {
    const schema = db.getTableSchema(tableName);
    let content = `<h1>Управление Структурой Таблицы: ${tableName}</h1>`;

    // Форма добавления новой колонки
    content += `
      <h3>Добавить Новую Колонку</h3>
      <form action="/table/${encodeURIComponent(tableName)}/add-column" method="POST" class="mb-4">
        <div class="form-row">
          <div class="col-md-5 mb-3">
            <label for="columnName">Название Колонки</label>
            <input type="text" class="form-control" id="columnName" name="columnName" placeholder="Например: email" required>
          </div>
          <div class="col-md-5 mb-3">
            <label for="columnType">Тип Колонки</label>
            <select class="form-control" id="columnType" name="columnType" required>
              <option value="" disabled selected>Выберите тип</option>
              <option value="number">Number</option>
              <option value="string">String</option>
            </select>
          </div>
          <div class="col-md-2 mb-3 align-self-end">
            <button type="submit" class="btn btn-success">Добавить</button>
          </div>
        </div>
      </form>
    `;

    // Таблица текущей схемы
    content += `
      <h3>Текущая Структура Таблицы</h3>
      <table class="table table-bordered table-hover">
        <thead class="thead-light">
          <tr>
            <th>Название Колонки</th>
            <th>Тип</th>
            <th>Действия</th>
          </tr>
        </thead>
        <tbody>
    `;
    for (let field in schema) {
      content += `
        <tr>
          <td>${field}</td>
          <td>${schema[field]}</td>
          <td>
            ${field !== 'id' ? `
            <form action="/table/${encodeURIComponent(tableName)}/delete-column" method="POST" onsubmit="return confirm('Вы уверены, что хотите удалить колонку "${field}"? Это приведет к потере всех данных в этой колонке.');">
              <input type="hidden" name="columnName" value="${field}">
              <button type="submit" class="btn btn-danger btn-sm">Удалить</button>
            </form>
            ` : `<span class="text-muted">Обязательная колонка</span>`}
          </td>
        </tr>
      `;
    }
    content += `
        </tbody>
      </table>
      <a href="/table/${encodeURIComponent(tableName)}" class="btn btn-secondary">Назад</a>
    `;
    renderPage(res, `Управление Структурой ${tableName}`, content);
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Обработка добавления новой колонки
app.post('/table/:tableName/add-column', (req, res) => {
  const tableName = req.params.tableName;
  const { columnName, columnType } = req.body;
  try {
    db.addColumn(tableName, columnName, columnType);
    res.redirect(`/table/${encodeURIComponent(tableName)}/manage-schema`);
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/table/${encodeURIComponent(tableName)}/manage-schema" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Обработка удаления колонки
app.post('/table/:tableName/delete-column', (req, res) => {
  const tableName = req.params.tableName;
  const { columnName } = req.body;
  try {
    db.deleteColumn(tableName, columnName);
    res.redirect(`/table/${encodeURIComponent(tableName)}/manage-schema`);
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/table/${encodeURIComponent(tableName)}/manage-schema" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Страница отображения таблицы и ее записей
app.get('/table/:tableName', (req, res) => {
  const tableName = req.params.tableName;
  try {
    const records = db.getAll(tableName);
    const schema = db.getTableSchema(tableName);
    let content = `<h1>Таблица: ${tableName}</h1>`;
    content += `
      <div class="mb-3">
        <a href="/table/${encodeURIComponent(tableName)}/add" class="btn btn-success">Добавить Запись</a>
        <a href="/table/${encodeURIComponent(tableName)}/manage-schema" class="btn btn-secondary">Управление Структурой</a>
      </div>
    `;
    content += `
      <div class="table-responsive">
        <table class="table table-bordered table-hover">
          <thead class="thead-dark">
            <tr>
    `;
    for (let field in schema) {
      content += `<th>${field}</th>`;
    }
    content += `<th>Действия</th></tr></thead><tbody>`;
    if (records.length === 0) {
      content += `
        <tr>
          <td colspan="${Object.keys(schema).length + 1}" class="text-center">Нет записей.</td>
        </tr>
      `;
    } else {
      records.forEach(record => {
        content += `<tr>`;
        for (let field in schema) {
          content += `<td>${record[field]}</td>`;
        }
        content += `
          <td>
            <div class="table-actions">
              <a href="/table/${encodeURIComponent(tableName)}/edit/${encodeURIComponent(record.id)}" class="btn btn-primary btn-sm">Редактировать</a>
              <form action="/table/${encodeURIComponent(tableName)}/delete/${encodeURIComponent(record.id)}" method="POST" onsubmit="return confirm('Вы уверены, что хотите удалить запись с id=${record.id}?');">
                <button type="submit" class="btn btn-danger btn-sm">Удалить</button>
              </form>
            </div>
          </td>
        `;
        content += `</tr>`;
      });
    }
    content += `</tbody></table></div>`;
    content += `<a href="/" class="btn btn-secondary">Назад</a>`;
    renderPage(res, `Таблица: ${tableName}`, content);
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Страница добавления новой записи
app.get('/table/:tableName/add', (req, res) => {
  const tableName = req.params.tableName;
  try {
    const schema = db.getTableSchema(tableName);
    let formFields = '';
    for (let field in schema) {
      formFields += `
        <div class="form-group">
          <label for="${field}">${field} (${schema[field]})</label>
          ${schema[field] === 'number' ? `
            <input type="number" class="form-control" id="${field}" name="${field}" required>
          ` : `
            <input type="text" class="form-control" id="${field}" name="${field}" required>
          `}
        </div>
      `;
    }
    const content = `
      <h1>Добавить Запись в Таблицу: ${tableName}</h1>
      <form action="/table/${encodeURIComponent(tableName)}/add" method="POST">
        ${formFields}
        <button type="submit" class="btn btn-primary">Добавить Запись</button>
        <a href="/table/${encodeURIComponent(tableName)}" class="btn btn-secondary">Отмена</a>
      </form>
    `;
    renderPage(res, `Добавить Запись в ${tableName}`, content);
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Обработка добавления новой записи
app.post('/table/:tableName/add', (req, res) => {
  const tableName = req.params.tableName;
  const record = req.body;
  try {
    const schema = db.getTableSchema(tableName);
    // Преобразование типов полей
    for (const field in record) {
      if (schema[field] === 'number') {
        record[field] = Number(record[field]);
        if (isNaN(record[field])) {
          throw new Error(`Поле "${field}" должно быть числом.`);
        }
      }
    }
    db.insert(tableName, record);
    res.redirect(`/table/${encodeURIComponent(tableName)}`);
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/table/${encodeURIComponent(tableName)}/add" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Страница редактирования записи
app.get('/table/:tableName/edit/:id', (req, res) => {
  const tableName = req.params.tableName;
  const id = req.params.id;
  try {
    const record = db.get(tableName, Number(id));
    if (!record) {
      throw new Error(`Запись с id=${id} не найдена.`);
    }
    const schema = db.getTableSchema(tableName);
    let formFields = '';
    for (let field in schema) {
      formFields += `
        <div class="form-group">
          <label for="${field}">${field} (${schema[field]})</label>
          ${schema[field] === 'number' ? `
            <input type="number" class="form-control" id="${field}" name="${field}" value="${record[field]}" required>
          ` : `
            <input type="text" class="form-control" id="${field}" name="${field}" value="${record[field]}" required>
          `}
        </div>
      `;
    }
    const content = `
      <h1>Редактировать Запись в Таблице: ${tableName}</h1>
      <form action="/table/${encodeURIComponent(tableName)}/edit/${encodeURIComponent(id)}" method="POST">
        ${formFields}
        <button type="submit" class="btn btn-primary">Сохранить Изменения</button>
        <a href="/table/${encodeURIComponent(tableName)}" class="btn btn-secondary">Отмена</a>
      </form>
    `;
    renderPage(res, `Редактировать Запись в ${tableName}`, content);
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Обработка редактирования записи
app.post('/table/:tableName/edit/:id', (req, res) => {
  const tableName = req.params.tableName;
  const id = req.params.id;
  const newRecord = req.body;
  try {
    const schema = db.getTableSchema(tableName);
    // Преобразование типов полей
    for (const field in newRecord) {
      if (schema[field] === 'number') {
        newRecord[field] = Number(newRecord[field]);
        if (isNaN(newRecord[field])) {
          throw new Error(`Поле "${field}" должно быть числом.`);
        }
      }
    }
    const success = db.update(tableName, Number(id), newRecord);
    if (!success) {
      throw new Error(`Запись с id=${id} не найдена.`);
    }
    res.redirect(`/table/${encodeURIComponent(tableName)}`);
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/table/${encodeURIComponent(tableName)}/edit/${encodeURIComponent(id)}" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Обработка удаления записи
app.post('/table/:tableName/delete/:id', (req, res) => {
  const tableName = req.params.tableName;
  const id = req.params.id;
  try {
    const success = db.delete(tableName, Number(id));
    if (!success) {
      throw new Error(`Запись с id=${id} не найдена.`);
    }
    res.redirect(`/table/${encodeURIComponent(tableName)}`);
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/table/${encodeURIComponent(tableName)}" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Обработка удаления таблицы
app.post('/drop-table/:tableName', (req, res) => {
  const tableName = req.params.tableName;
  try {
    db.dropTable(tableName);
    res.redirect('/');
  } catch (error) {
    const content = `
      <div class="alert alert-danger" role="alert">
        <h4 class="alert-heading">Ошибка</h4>
        <p>${error.message}</p>
        <hr>
        <a href="/" class="btn btn-primary">Назад</a>
      </div>
    `;
    renderPage(res, 'Ошибка', content);
  }
});

// Запуск сервера
const server = app.listen(PORT, () => {
  console.log(`Сервер запущен на http://localhost:${PORT}`);
});

// Обработка завершения работы для сохранения данных
process.on('SIGINT', () => {
  console.log('\nЗавершение работы...');
  db.saveToFile(DATA_FILE);
  server.close(() => {
    console.log('Сервер остановлен.');
    process.exit(0);
  });
});