перепиши мой код  замени все команды к базе на синтексис как у sql    ,  api post в ответ json
Регистрация авторизация по api  создаёться для каждого пользывателя своя база папка с именем пользыватяля , у пользывателя есть у каждого свой токен для запросов к его базе
// index.js

const { GPU } = require('gpu.js');
const fs = require('fs').promises;

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

// Структура таблиц базы данных
const tables = {
  Users: {
    schema: {
      userId: 'INT',
      username: 'STRING',
      email: 'STRING',
      createdAt: 'DATETIME'
    },
    indexes: ['userId', 'username'],
    records: new Map()
  },
  Orders: {
    schema: {
      orderId: 'INT',
      userId: 'INT',
      product: 'STRING',
      amount: 'FLOAT',
      orderDate: 'DATETIME'
    },
    indexes: ['orderId', 'userId'],
    records: new Map()
  }
};

// Массив для хранения информации о выполненных операциях
const operationStats = [];

// Кеш для результатов вычислений
const sumCache = new Map();

/**
 * Функция для измерения времени выполнения операций
 * @param {Function} func - Функция, которую нужно выполнить
 * @param {string} operationName - Название операции для логирования
 * @returns {any} - Возвращает результат выполнения функции
 */
function measureExecutionTime(func, operationName) {
  const start = process.hrtime.bigint();
  const result = func();
  const end = process.hrtime.bigint();
  const timeInSeconds = Number(end - start) / 1e9;
  operationStats.push({ operationName, timeInSeconds });
  return result;
}

/**
 * Функция логирования результатов с форматированием
 * @param {string} message - Сообщение для логирования
 */
function logResult(message) {
  console.log(message);
}

/**
 * Определение глобального кернела для суммирования
 */
const sumKernel = gpu.createKernel(function(arr, len) {
  let sum = 0;
  for (let i = 0; i < len; i++) {
    sum += arr[i];
  }
  return sum;
})
.setOutput([1]) // Один выходной элемент
.setConstants({ len: 0 }) // Инициализация, будет обновляться
.setPipeline(false); // Результат не в виде текстуры

/**
 * Функция для суммирования массива с использованием GPU
 * @param {number[]} arr - Массив чисел для суммирования
 * @param {number} len - Длина массива
 * @returns {number} - Сумма элементов массива
 */
function gpuSum(arr, len) {
  // Проверка кеша
  const cacheKey = arr.join(',');
  if (sumCache.has(cacheKey)) {
    logResult(`Использование кешированных результатов для суммы массива.`);
    return sumCache.get(cacheKey);
  }

  // Обновление константы длины массива
  sumKernel.constants.len = len;

  // Выполнение кернел функции
  const total = sumKernel(arr, len)[0];

  // Кеширование результата
  sumCache.set(cacheKey, total);
  return total;
}

/**
 * Функция добавления записи
 * @param {string} tableName - Имя таблицы
 * @param {object} record - Объект записи
 */
function addRecord(tableName, record) {
  return measureExecutionTime(() => {
    const table = tables[tableName];
    if (!table) {
      throw new Error(`Таблица "${tableName}" не существует.`);
    }

    // Генерация ключа для хранения записи
    const primaryKey = table.indexes[0];
    const key = `${record[primaryKey]}`;

    // Проверка на уникальность ключа
    if (table.records.has(key)) {
      throw new Error(`Запись с ключом "${key}" уже существует в таблице "${tableName}".`);
    }

    table.records.set(key, record);
    logResult(`Запись добавлена в таблицу "${tableName}": ${JSON.stringify(record)}`);
  }, `Добавление записи в таблицу "${tableName}"`);
}

/**
 * Функция чтения записей по определенному критерию
 * @param {string} tableName - Имя таблицы
 * @param {string} queryKey - Ключ для поиска
 * @param {any} queryValue - Значение для поиска
 * @returns {Array} - Массив найденных записей
 */
function readRecords(tableName, queryKey, queryValue) {
  return measureExecutionTime(() => {
    const table = tables[tableName];
    if (!table) {
      throw new Error(`Таблица "${tableName}" не существует.`);
    }

    const results = [];
    const isIndexed = table.indexes.includes(queryKey);

    if (isIndexed) {
      for (let record of table.records.values()) {
        if (record[queryKey] === queryValue) {
          results.push(record);
        }
      }
    } else {
      for (let record of table.records.values()) {
        if (record[queryKey] === queryValue) {
          results.push(record);
        }
      }
    }

    logResult(`Найдено записей в таблице "${tableName}": ${results.length}`);
    return results;
  }, `Чтение записей из таблицы "${tableName}" по ключу "${queryKey}" = "${queryValue}"`);
}

/**
 * Функция изменения записи
 * @param {string} tableName - Имя таблицы
 * @param {any} recordId - Идентификатор записи
 * @param {object} updatedFields - Поля для обновления
 */
function modifyRecord(tableName, recordId, updatedFields) {
  return measureExecutionTime(() => {
    const table = tables[tableName];
    if (!table) {
      throw new Error(`Таблица "${tableName}" не существует.`);
    }

    const key = `${recordId}`;

    if (!table.records.has(key)) {
      throw new Error(`Запись с ключом "${key}" не найдена в таблице "${tableName}".`);
    }

    const record = table.records.get(key);
    const updatedRecord = { ...record, ...updatedFields };

    table.records.set(key, updatedRecord);
    logResult(`Запись с ключом "${key}" обновлена: ${JSON.stringify(updatedRecord)}`);
  }, `Изменение записи в таблице "${tableName}" с ID "${recordId}"`);
}

/**
 * Функция удаления записи
 * @param {string} tableName - Имя таблицы
 * @param {any} recordId - Идентификатор записи
 */
function deleteRecord(tableName, recordId) {
  return measureExecutionTime(() => {
    const table = tables[tableName];
    if (!table) {
      throw new Error(`Таблица "${tableName}" не существует.`);
    }

    const key = `${recordId}`;

    if (!table.records.has(key)) {
      throw new Error(`Запись с ключом "${key}" не найдена в таблице "${tableName}".`);
    }

    table.records.delete(key);
    logResult(`Запись с ключом "${key}" удалена из таблицы "${tableName}".`);
  }, `Удаление записи из таблицы "${tableName}" с ID "${recordId}"`);
}

/**
 * Пример использования GPU для вычислений
 * Например, подсчет общего количества заказов определенного продукта с кешированием
 * @param {string} productName - Название продукта для фильтрации
 * @returns {number} - Общее количество заказов
 */
function computeTotalOrdersByProduct(productName) {
  return measureExecutionTime(() => {
    // Проверка кеша
    if (sumCache.has(productName)) {
      logResult(`Использование кешированных результатов для продукта "${productName}".`);
      return sumCache.get(productName);
    }

    // Получение всех заказов по продукту
    const orders = readRecords('Orders', 'product', productName);
    const amounts = orders.map(order => order.amount);

    if (amounts.length === 0) {
      logResult(`Нет заказов для продукта "${productName}".`);
      sumCache.set(productName, 0);
      return 0;
    }

    // Использование GPU для суммирования
    const total = gpuSum(amounts, amounts.length);
    logResult(`Общее количество заказов для продукта "${productName}": ${total}`);
    sumCache.set(productName, total);
    return total;
  }, `Подсчет общего количества заказов для продукта "${productName}"`);
}

/**
 * Асинхронная функция для сохранения данных таблицы на диск
 */
async function saveTableToDisk(tableName) {
  try {
    const table = tables[tableName];
    if (!table) {
      throw new Error(`Таблица "${tableName}" не существует.`);
    }

    const data = Array.from(table.records.values());
    await fs.writeFile(`${tableName}.json`, JSON.stringify(data, null, 2));
    logResult(`Данные таблицы "${tableName}" сохранены на диск.`);
  } catch (error) {
    console.error(`Ошибка при сохранении таблицы "${tableName}":`, error.message);
  }
}

/**
 * Асинхронная функция загрузки данных из диска
 */
async function loadTableFromDisk(tableName) {
  try {
    const table = tables[tableName];
    if (!table) {
      throw new Error(`Таблица "${tableName}" не существует.`);
    }

    const data = await fs.readFile(`${tableName}.json`, 'utf-8');
    const records = JSON.parse(data);
    records.forEach(record => {
      const primaryKey = table.indexes[0];
      const key = `${record[primaryKey]}`;
      table.records.set(key, record);
    });
    logResult(`Данные таблицы "${tableName}" загружены из диска.`);
  } catch (error) {
    console.error(`Ошибка при загрузке таблицы "${tableName}":`, error.message);
  }
}

/**
 * Функция для генерации статистики по выполненным операциям
 */
function generateStatistics() {
  if (operationStats.length === 0) {
    console.log('\n--- Нет выполненных операций для статистики ---\n');
    return;
  }

  const totalTime = operationStats.reduce((acc, curr) => acc + curr.timeInSeconds, 0);
  const averageTime = totalTime / operationStats.length;
  const minTime = Math.min(...operationStats.map(op => op.timeInSeconds));
  const maxTime = Math.max(...operationStats.map(op => op.timeInSeconds));

  console.log('\n--- Статистика по времени выполнения операций ---');
  console.log(`Всего операций: ${operationStats.length}`);
  console.log(`Общее время выполнения: ${totalTime.toFixed(6)} секунд`);
  console.log(`Среднее время выполнения: ${averageTime.toFixed(6)} секунд`);
  console.log(`Минимальное время выполнения: ${minTime.toFixed(6)} секунд`);
  console.log(`Максимальное время выполнения: ${maxTime.toFixed(6)} секунд`);
  console.log('-----------------------------------------------\n');
}

/**
 * Примеры использования CRUD операций
 */
async function runExamples() {
  try {
    // Добавление пользователей
    addRecord("Users", { userId: 1, username: "john_doe", email: "john@example.com", createdAt: new Date() });
    addRecord("Users", { userId: 2, username: "jane_doe", email: "jane@example.com", createdAt: new Date() });

    // Добавление заказов
    addRecord("Orders", { orderId: 101, userId: 1, product: "Laptop", amount: 1500.00, orderDate: new Date() });
    addRecord("Orders", { orderId: 102, userId: 1, product: "Mouse", amount: 25.50, orderDate: new Date() });
    addRecord("Orders", { orderId: 103, userId: 2, product: "Keyboard", amount: 45.00, orderDate: new Date() });
    addRecord("Orders", { orderId: 104, userId: 2, product: "Monitor", amount: 300.00, orderDate: new Date() });
    addRecord("Orders", { orderId: 105, userId: 1, product: "Laptop", amount: 1500.00, orderDate: new Date() });

    // Чтение пользователей по username
    const users = readRecords("Users", "username", "john_doe");
    logResult(`Пользователи с username "john_doe": ${JSON.stringify(users)}`);

    // Изменение электронной почты пользователя
    modifyRecord("Users", 1, { email: "john.doe@newdomain.com" });

    // Чтение пользователя после обновления
    const updatedUser = readRecords("Users", "userId", 1);
    logResult(`Обновленный пользователь с userId 1: ${JSON.stringify(updatedUser)}`);

    // Удаление пользователя
    deleteRecord("Users", 2);

    // Попытка чтения удаленного пользователя
    const deletedUser = readRecords("Users", "userId", 2);
    logResult(`Попытка чтения удаленного пользователя с userId 2: ${JSON.stringify(deletedUser)}`);

    // Использование GPU для подсчета общего количества заказов по продукту
    computeTotalOrdersByProduct("Laptop");
    computeTotalOrdersByProduct("Mouse");
    computeTotalOrdersByProduct("Keyboard");
    computeTotalOrdersByProduct("Monitor");
    computeTotalOrdersByProduct("Tablet"); // Пример продукта без заказов

    // Асинхронное сохранение данных таблицы на диск
    await saveTableToDisk("Users");
    await saveTableToDisk("Orders");

    // Асинхронная загрузка данных таблицы из диска
    await loadTableFromDisk("Users");
    await loadTableFromDisk("Orders");

    // Генерация статистики
    generateStatistics();

  } catch (error) {
    console.error("Ошибка:", error.message);
  }
}

// Запуск примеров
runExamples();