Update index.js

index.js

@@ -3,186 +3,162 @@ const { Worker: ThreadWorker, isMainThread, parentPort, workerData } = require('
 
 // ============ DATABASE WORKER THREAD ============
 if (!isMainThread) {
-    const Database = require('better-sqlite3');
-    const path = require('path');
-    const fs = require('fs');
-    
-    const DATA_DIR = workerData.dataDir || "/data";
-    if (!fs.existsSync(DATA_DIR)) {
-        fs.mkdirSync(DATA_DIR, { recursive: true });
-    }
-    
-    const dbPath = path.join(DATA_DIR, 'users.db');
-    const db = new Database(dbPath);
-    
-    db.pragma('journal_mode = WAL');
-    db.pragma('synchronous = OFF');
-    db.pragma('cache_size = -2000000');
-    db.pragma('temp_store = MEMORY');
-    db.pragma('mmap_size = 268435456');
-    
-    db.exec(`
-        CREATE TABLE IF NOT EXISTS users (
-            id TEXT PRIMARY KEY,
-            username TEXT UNIQUE NOT NULL,
-            password_hash TEXT NOT NULL,
-            name TEXT NOT NULL,
-            created_at TEXT NOT NULL,
-            is_login INTEGER DEFAULT 0,
-            bio TEXT DEFAULT '',
-            pic_url TEXT DEFAULT '',
-            date_of_birth TEXT DEFAULT '',
-            is_profile_public TEXT DEFAULT 'true'
-        )
-    `);
-    
-    db.exec(`CREATE INDEX IF NOT EXISTS idx_username ON users(username);`);
-    
-    const stmts = {
-        getAllUsers: db.prepare('SELECT * FROM users'),
-        getUserById: db.prepare('SELECT * FROM users WHERE id = ?'),
-        getUserByUsername: db.prepare('SELECT * FROM users WHERE username = ?'),
-        insertUser: db.prepare(`
-            INSERT INTO users (
-                id, username, password_hash, name, created_at, is_login,
-                bio, pic_url, date_of_birth, is_profile_public
-            ) VALUES (
-                @id, @username, @password_hash, @name, @created_at, @is_login,
-                @bio, @pic_url, @date_of_birth, @is_profile_public
-            )
-        `),
-        updateLogin: db.prepare('UPDATE users SET is_login = ? WHERE id = ?'),
-        updateProfileWithUsername: db.prepare(`
-  UPDATE users SET 
-    username = @username,
-    name = @name,
-    bio = @bio,
-    date_of_birth = @date_of_birth,
-    is_profile_public = @is_profile_public
-  WHERE id = @id
-`),
-        updatePhoto: db.prepare('UPDATE users SET pic_url = ? WHERE id = ?'),
-        getCount: db.prepare('SELECT COUNT(*) as count FROM users')
-    };
-    
-    parentPort.on('message', async (message) => {
-        const { id, action, data } = message;
-        try {
-            let result;
-            switch (action) {
-                case 'getAllUsers':
-                    result = stmts.getAllUsers.all();
-                    break;
-                case 'getUserById':
-                    result = stmts.getUserById.get(data.userId);
-                    break;
-                case 'getUserByUsername':
-                    result = stmts.getUserByUsername.get(data.username);
-                    break;
-                case 'insertUser':
-                    stmts.insertUser.run(data.user);
-                    result = { success: true };
-                    break;
-                case 'updateLogin':
-                    stmts.updateLogin.run(data.isLogin ? 1 : 0, data.userId);
-                    result = { success: true };
-                    break;
-                case 'updateProfile':
-  if (data.username) {
-    stmts.updateProfileWithUsername.run({
-      id: data.userId,
-      username: data.username,
-      name: data.name,
-      bio: data.bio,
-      date_of_birth: data.date_of_birth,
-      is_profile_public: data.is_profile_public
-    });
-  } else {
-    stmts.updateProfile.run({
-      id: data.userId,
-      name: data.name,
-      bio: data.bio,
-      date_of_birth: data.date_of_birth,
-      is_profile_public: data.is_profile_public
-    });
+  const Database = require('better-sqlite3');
+  const path = require('path');
+  const fs = require('fs');
+  
+  const DATA_DIR = workerData.dataDir || "/data";
+  if (!fs.existsSync(DATA_DIR)) {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
   }
-  result = { success: true };
-  break;
-                case 'updatePhoto':
-                    stmts.updatePhoto.run(data.picUrl, data.userId);
-                    result = { success: true };
-                    break;
-                case 'batchOperation':
-                    result = processBatch(data.operations);
-                    break;
-                case 'getCount':
-                    result = stmts.getCount.get().count;
-                    break;
-                default:
-                    throw new Error(`Unknown action: ${action}`);
-            }
-            parentPort.postMessage({ id, success: true, result });
-        } catch (error) {
-            parentPort.postMessage({ id, success: false, error: error.message });
+  
+  const dbPath = path.join(DATA_DIR, 'users.db');
+  const db = new Database(dbPath);
+  
+  db.pragma('journal_mode = WAL');
+  db.pragma('synchronous = OFF');
+  db.pragma('cache_size = -2000000');
+  db.pragma('temp_store = MEMORY');
+  db.pragma('mmap_size = 268435456');
+  
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS users (
+      id TEXT PRIMARY KEY,
+      username TEXT UNIQUE NOT NULL,
+      password_hash TEXT NOT NULL,
+      name TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      is_login INTEGER DEFAULT 0,
+      bio TEXT DEFAULT '',
+      pic_url TEXT DEFAULT '',
+      date_of_birth TEXT DEFAULT '',
+      is_profile_public TEXT DEFAULT 'true'
+    )
+  `);
+  
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_username ON users(username);`);
+  
+  const stmts = {
+    getAllUsers: db.prepare('SELECT * FROM users'),
+    getUserById: db.prepare('SELECT * FROM users WHERE id = ?'),
+    getUserByUsername: db.prepare('SELECT * FROM users WHERE username = ?'),
+    insertUser: db.prepare(`
+      INSERT INTO users (
+        id, username, password_hash, name, created_at, is_login, bio, pic_url, date_of_birth, is_profile_public
+      ) VALUES (
+        @id, @username, @password_hash, @name, @created_at, @is_login, @bio, @pic_url, @date_of_birth, @is_profile_public
+      )
+    `),
+    updateLogin: db.prepare('UPDATE users SET is_login = ? WHERE id = ?'),
+    updateProfile: db.prepare(`
+      UPDATE users SET 
+        username = COALESCE(NULLIF(@username, ''), username),
+        name = COALESCE(NULLIF(@name, ''), name),
+        bio = COALESCE(NULLIF(@bio, ''), bio),
+        date_of_birth = COALESCE(NULLIF(@date_of_birth, ''), date_of_birth),
+        is_profile_public = COALESCE(NULLIF(@is_profile_public, ''), is_profile_public)
+      WHERE id = @id
+    `),
+    updatePhoto: db.prepare('UPDATE users SET pic_url = ? WHERE id = ?'),
+    getCount: db.prepare('SELECT COUNT(*) as count FROM users')
+  };
+  
+  parentPort.on('message', async (message) => {
+    const { id, action, data } = message;
+    try {
+      let result;
+      switch (action) {
+        case 'getAllUsers':
+          result = stmts.getAllUsers.all();
+          break;
+        case 'getUserById':
+          result = stmts.getUserById.get(data.userId);
+          break;
+        case 'getUserByUsername':
+          result = stmts.getUserByUsername.get(data.username);
+          break;
+        case 'insertUser':
+          stmts.insertUser.run(data.user);
+          result = { success: true };
+          break;
+        case 'updateLogin':
+          stmts.updateLogin.run(data.isLogin ? 1 : 0, data.userId);
+          result = { success: true };
+          break;
+        case 'updateProfile':
+          stmts.updateProfile.run({
+            id: data.userId,
+            username: data.username || '',
+            name: data.name || '',
+            bio: data.bio || '',
+            date_of_birth: data.date_of_birth || '',
+            is_profile_public: data.is_profile_public || 'true'
+          });
+          result = { success: true };
+          break;
+        case 'updatePhoto':
+          stmts.updatePhoto.run(data.picUrl, data.userId);
+          result = { success: true };
+          break;
+        case 'batchOperation':
+          result = processBatch(data.operations);
+          break;
+        case 'getCount':
+          result = stmts.getCount.get().count;
+          break;
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+      parentPort.postMessage({ id, success: true, result });
+    } catch (error) {
+      parentPort.postMessage({ id, success: false, error: error.message });
+    }
+  });
+  
+  function processBatch(operations) {
+    const transaction = db.transaction(() => {
+      for (const op of operations) {
+        switch (op.action) {
+          case 'signup':
+            try { stmts.insertUser.run(op.user); } catch (e) {}
+            break;
+          case 'login':
+            stmts.updateLogin.run(1, op.userId);
+            break;
+          case 'logout':
+            stmts.updateLogin.run(0, op.userId);
+            break;
+          case 'updateProfile':
+            stmts.updateProfile.run({
+              id: op.data.id || op.data.userId,
+              username: op.data.username || '',
+              name: op.data.name || '',
+              bio: op.data.bio || '',
+              date_of_birth: op.data.date_of_birth || '',
+              is_profile_public: op.data.is_profile_public || 'true'
+            });
+            break;
+          case 'updatePhoto':
+            stmts.updatePhoto.run(op.picUrl, op.userId);
+            break;
         }
+      }
     });
-    
-    function processBatch(operations) {
-        const transaction = db.transaction(() => {
-            for (const op of operations) {
-                switch (op.action) {
-                    case 'signup':
-                        try {
-                            stmts.insertUser.run(op.user);
-                        } catch (e) {}
-                        break;
-                    case 'login':
-                        stmts.updateLogin.run(1, op.userId);
-                        break;
-                    case 'logout':
-                        stmts.updateLogin.run(0, op.userId);
-                        break;
-                    case 'updateProfile':
-  if (op.data && op.data.username) {
-    stmts.updateProfileWithUsername.run({
-      id: op.data.id,
-      username: op.data.username,
-      name: op.data.name,
-      bio: op.data.bio,
-      date_of_birth: op.data.date_of_birth,
-      is_profile_public: op.data.is_profile_public
-    });
-  } else {
-    stmts.updateProfile.run({
-      id: op.data.id,
-      name: op.data.name,
-      bio: op.data.bio,
-      date_of_birth: op.data.date_of_birth,
-      is_profile_public: op.data.is_profile_public
-    });
+    transaction();
+    return { processed: operations.length };
   }
-  break;
-                    case 'updatePhoto':
-                        stmts.updatePhoto.run(op.picUrl, op.userId);
-                        break;
-                }
-            }
-        });
-        transaction();
-        return { processed: operations.length };
-    }
-    
-    return;
+  
+  return;
 }
 
 // ============ MAIN THREAD ============
-const fastify = require('fastify')({
-    logger: false,
-    bodyLimit: 1048576,
-    keepAliveTimeout: 61000,
-    connectionTimeout: 61000,
-    maxRequestsPerSocket: 0,
-    requestTimeout: 30000
+const fastify = require('fastify')({ 
+  logger: false, 
+  bodyLimit: 1048576, 
+  keepAliveTimeout: 61000, 
+  connectionTimeout: 61000, 
+  maxRequestsPerSocket: 0, 
+  requestTimeout: 30000
 });
 
 const cors = require('@fastify/cors');
@@ -194,9 +170,7 @@ const fsp = require('fs').promises;
 const path = require('path');
 
 let sharp;
-try {
-    sharp = require('sharp');
-} catch (e) {}
+try { sharp = require('sharp'); } catch (e) {}
 
 const MAX_BUCKET_SIZE = 60 * 1024 * 1024 * 1024;
 const MAX_USERS = 30000;
@@ -223,81 +197,79 @@ const FULL_FILE = path.join(STATUS_DIR, "full.txt");
 const SIZE_FILE = path.join(STATUS_DIR, "size.txt");
 
 [DATA_DIR, PHOTOS_DIR, STATUS_DIR].forEach(dir => {
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 });
 
 if (!fs.existsSync(FULL_FILE)) fs.writeFileSync(FULL_FILE, '', 'utf8');
 if (!fs.existsSync(SIZE_FILE)) fs.writeFileSync(SIZE_FILE, '', 'utf8');
 
 async function getFullSpaces() {
-    try {
-        const content = await fsp.readFile(FULL_FILE, 'utf8');
-        return content.trim() ? content.trim().split('|') : [];
-    } catch (e) {
-        return [];
-    }
+  try {
+    const content = await fsp.readFile(FULL_FILE, 'utf8');
+    return content.trim() ? content.trim().split('|') : [];
+  } catch (e) { return []; }
 }
 
 async function addSpaceToFull() {
-    try {
-        let content = await fsp.readFile(FULL_FILE, 'utf8').catch(() => '');
-        content = content.trim();
-        let spaces = content ? content.split('|') : [];
-        if (!spaces.includes(SPACE_NAME)) {
-            spaces.push(SPACE_NAME);
-            await fsp.writeFile(FULL_FILE, spaces.join('|'), 'utf8');
-        }
-    } catch (e) {}
+  try {
+    let content = await fsp.readFile(FULL_FILE, 'utf8').catch(() => '');
+    content = content.trim();
+    let spaces = content ? content.split('|') : [];
+    if (!spaces.includes(SPACE_NAME)) {
+      spaces.push(SPACE_NAME);
+      await fsp.writeFile(FULL_FILE, spaces.join('|'), 'utf8');
+    }
+  } catch (e) {}
 }
 
 async function removeSpaceFromFull() {
-    try {
-        let content = await fsp.readFile(FULL_FILE, 'utf8').catch(() => '');
-        content = content.trim();
-        let spaces = content ? content.split('|') : [];
-        const newSpaces = spaces.filter(s => s !== SPACE_NAME);
-        if (newSpaces.length !== spaces.length) {
-            await fsp.writeFile(FULL_FILE, newSpaces.join('|'), 'utf8');
-        }
-    } catch (e) {}
+  try {
+    let content = await fsp.readFile(FULL_FILE, 'utf8').catch(() => '');
+    content = content.trim();
+    let spaces = content ? content.split('|') : [];
+    const newSpaces = spaces.filter(s => s !== SPACE_NAME);
+    if (newSpaces.length !== spaces.length) {
+      await fsp.writeFile(FULL_FILE, newSpaces.join('|'), 'utf8');
+    }
+  } catch (e) {}
 }
 
 async function addSpaceToSize() {
-    try {
-        let content = await fsp.readFile(SIZE_FILE, 'utf8').catch(() => '');
-        content = content.trim();
-        let spaces = content ? content.split('|') : [];
-        if (!spaces.includes(SPACE_NAME)) {
-            spaces.push(SPACE_NAME);
-            await fsp.writeFile(SIZE_FILE, spaces.join('|'), 'utf8');
-        }
-    } catch (e) {}
+  try {
+    let content = await fsp.readFile(SIZE_FILE, 'utf8').catch(() => '');
+    content = content.trim();
+    let spaces = content ? content.split('|') : [];
+    if (!spaces.includes(SPACE_NAME)) {
+      spaces.push(SPACE_NAME);
+      await fsp.writeFile(SIZE_FILE, spaces.join('|'), 'utf8');
+    }
+  } catch (e) {}
 }
 
 function checkRPSStatus() {
-    const now = Date.now();
-    if (now - rpsWindowStart >= 1000) {
-        if (currentRPS >= MAX_RPS * 0.9 && !isSpaceFull_RPS) {
-            isSpaceFull_RPS = true;
-            addSpaceToFull();
-        } else if (currentRPS < MAX_RPS * 0.7 && isSpaceFull_RPS) {
-            isSpaceFull_RPS = false;
-            removeSpaceFromFull();
-        }
-        currentRPS = 0;
-        rpsWindowStart = now;
+  const now = Date.now();
+  if (now - rpsWindowStart >= 1000) {
+    if (currentRPS >= MAX_RPS * 0.9 && !isSpaceFull_RPS) {
+      isSpaceFull_RPS = true;
+      addSpaceToFull();
+    } else if (currentRPS < MAX_RPS * 0.7 && isSpaceFull_RPS) {
+      isSpaceFull_RPS = false;
+      removeSpaceFromFull();
     }
+    currentRPS = 0;
+    rpsWindowStart = now;
+  }
 }
 
 async function checkUserCountStatus() {
-    try {
-        const count = await dbRequest('getCount');
-        if (count >= MAX_USERS && !isSpaceFull_Users) {
-            isSpaceFull_Users = true;
-            await addSpaceToSize();
-            await addSpaceToFull();
-        }
-    } catch (e) {}
+  try {
+    const count = await dbRequest('getCount');
+    if (count >= MAX_USERS && !isSpaceFull_Users) {
+      isSpaceFull_Users = true;
+      await addSpaceToSize();
+      await addSpaceToFull();
+    }
+  } catch (e) {}
 }
 
 let dbWorker;
@@ -305,408 +277,364 @@ let dbRequestId = 0;
 const dbPromises = new Map();
 
 function initDBWorker() {
-    return new Promise((resolve, reject) => {
-        dbWorker = new ThreadWorker(__filename, {
-            workerData: { dataDir: DATA_DIR }
-        });
-        dbWorker.on('message', (message) => {
-            const { id, success, result, error } = message;
-            const promise = dbPromises.get(id);
-            if (promise) {
-                dbPromises.delete(id);
-                if (success) promise.resolve(result);
-                else promise.reject(new Error(error));
-            }
-        });
-        dbWorker.on('error', reject);
-        dbWorker.on('online', resolve);
+  return new Promise((resolve, reject) => {
+    dbWorker = new ThreadWorker(__filename, { workerData: { dataDir: DATA_DIR } });
+    dbWorker.on('message', (message) => {
+      const { id, success, result, error } = message;
+      const promise = dbPromises.get(id);
+      if (promise) {
+        dbPromises.delete(id);
+        if (success) promise.resolve(result);
+        else promise.reject(new Error(error));
+      }
     });
+    dbWorker.on('error', reject);
+    dbWorker.on('online', resolve);
+  });
 }
 
 function dbRequest(action, data = {}) {
-    return new Promise((resolve, reject) => {
-        const id = ++dbRequestId;
-        dbPromises.set(id, { resolve, reject });
-        dbWorker.postMessage({ id, action, data });
-    });
+  return new Promise((resolve, reject) => {
+    const id = ++dbRequestId;
+    dbPromises.set(id, { resolve, reject });
+    dbWorker.postMessage({ id, action, data });
+  });
 }
 
 class FastRateLimiter {
-    constructor(maxRequests = 15000, windowMs = 1000) {
-        this.maxRequests = maxRequests;
-        this.windowMs = windowMs;
-        this.requests = 0;
-        this.windowStart = Date.now();
-    }
-    
-    isAllowed() {
-        const now = Date.now();
-        if (now - this.windowStart >= this.windowMs) {
-            this.requests = 0;
-            this.windowStart = now;
-        }
-        if (this.requests >= this.maxRequests) return false;
-        this.requests++;
-        currentRPS++;
-        return true;
+  constructor(maxRequests = 15000, windowMs = 1000) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+    this.requests = 0;
+    this.windowStart = Date.now();
+  }
+  isAllowed() {
+    const now = Date.now();
+    if (now - this.windowStart >= this.windowMs) {
+      this.requests = 0;
+      this.windowStart = now;
     }
+    if (this.requests >= this.maxRequests) return false;
+    this.requests++;
+    currentRPS++;
+    return true;
+  }
 }
 
 const rateLimiter = new FastRateLimiter(15000, 1000);
 
 function hashPassword(password) {
-    return crypto.createHash('sha256').update(HASH + password + HASH).digest('hex');
+  return crypto.createHash('sha256').update(HASH + password + HASH).digest('hex');
 }
 
 function verifyPassword(password, hash) {
-    return hashPassword(password) === hash;
+  return hashPassword(password) === hash;
 }
 
 function generateId() {
-    return crypto.randomBytes(16).toString('base64url').substring(0, 21);
+  return crypto.randomBytes(16).toString('base64url').substring(0, 21);
 }
 
 function getBucketSize() {
-    let totalSize = 0;
-    try {
-        const files = fs.readdirSync(PHOTOS_DIR);
-        for (const file of files) {
-            try {
-                totalSize += fs.statSync(path.join(PHOTOS_DIR, file)).size;
-            } catch (e) {}
-        }
-        try {
-            totalSize += fs.statSync(path.join(DATA_DIR, 'users.db')).size;
-        } catch (e) {}
-    } catch (e) {}
-    return totalSize;
+  let totalSize = 0;
+  try {
+    const files = fs.readdirSync(PHOTOS_DIR);
+    for (const file of files) {
+      try { totalSize += fs.statSync(path.join(PHOTOS_DIR, file)).size; } catch (e) {}
+    }
+    try { totalSize += fs.statSync(path.join(DATA_DIR, 'users.db')).size; } catch (e) {}
+  } catch (e) {}
+  return totalSize;
 }
 
 async function compressToWebp(fileData, maxSizeKb = 20) {
-    if (!sharp) return fileData;
-    try {
-        let image = sharp(fileData);
-        const metadata = await image.metadata();
-        const currentSizeKb = fileData.length / 1024;
-        if (metadata.format === 'webp' && currentSizeKb <= maxSizeKb) return fileData;
-        
-        let quality = 80;
-        let outputBuffer;
-        while (quality >= 10) {
-            outputBuffer = await image
-                .resize(800, 800, { fit: 'inside', withoutEnlargement: true })
-                .webp({ quality })
-                .toBuffer();
-            if (outputBuffer.length / 1024 <= maxSizeKb) break;
-            quality -= 10;
-        }
-        
-        if (outputBuffer.length / 1024 > maxSizeKb) {
-            outputBuffer = await image
-                .resize(400, 400, { fit: 'inside', withoutEnlargement: true })
-                .webp({ quality: 30 })
-                .toBuffer();
-        }
-        return outputBuffer;
-    } catch (e) {
-        return fileData;
+  if (!sharp) return fileData;
+  try {
+    let image = sharp(fileData);
+    const metadata = await image.metadata();
+    const currentSizeKb = fileData.length / 1024;
+    if (metadata.format === 'webp' && currentSizeKb <= maxSizeKb) return fileData;
+    let quality = 80;
+    let outputBuffer;
+    while (quality >= 10) {
+      outputBuffer = await image
+        .resize(800, 800, { fit: 'inside', withoutEnlargement: true })
+        .webp({ quality })
+        .toBuffer();
+      if (outputBuffer.length / 1024 <= maxSizeKb) break;
+      quality -= 10;
+    }
+    if (outputBuffer.length / 1024 > maxSizeKb) {
+      outputBuffer = await image
+        .resize(400, 400, { fit: 'inside', withoutEnlargement: true })
+        .webp({ quality: 30 })
+        .toBuffer();
     }
+    return outputBuffer;
+  } catch (e) { return fileData; }
 }
 
 async function setupFastify() {
-    await fastify.register(cors, { origin: '*' });
-    await fastify.register(multipart, { limits: { fileSize: 5 * 1024 * 1024 } });
-    await fastify.register(fastifyStatic, { root: PHOTOS_DIR, prefix: '/photos/', maxAge: 86400000 });
-    
-    fastify.addHook('onRequest', async (request, reply) => {
-        if (!rateLimiter.isAllowed()) {
-            reply.status(503).send({ error: 'rate_limit' });
-            return;
-        }
+  await fastify.register(cors, { origin: '*' });
+  await fastify.register(multipart, { limits: { fileSize: 5 * 1024 * 1024 } });
+  await fastify.register(fastifyStatic, { root: PHOTOS_DIR, prefix: '/photos/', maxAge: 86400000 });
+  
+  fastify.addHook('onRequest', async (request, reply) => {
+    if (!rateLimiter.isAllowed()) {
+      reply.status(503).send({ error: 'rate_limit' });
+      return;
+    }
+  });
+  
+  fastify.post('/signup', async (request, reply) => {
+    const { username, password, name } = request.body || {};
+    if (!username || !password || !name) {
+      reply.status(400).send({ detail: 'Missing fields' });
+      return;
+    }
+    const cleanUsername = username.trim().toLowerCase();
+    if (cleanUsername.length < 3 || cleanUsername.length > MAX_USERNAME_LENGTH) {
+      reply.status(400).send({ detail: `Username must be 3-${MAX_USERNAME_LENGTH} chars` });
+      return;
+    }
+    if (password.length < 6 || password.length > MAX_PASSWORD_LENGTH) {
+      reply.status(400).send({ detail: `Password must be 6-${MAX_PASSWORD_LENGTH} chars` });
+      return;
+    }
+    if (name.trim().length > MAX_NAME_LENGTH) {
+      reply.status(400).send({ detail: `Name max ${MAX_NAME_LENGTH} chars` });
+      return;
+    }
+    const existingUser = await dbRequest('getUserByUsername', { username: cleanUsername });
+    if (existingUser) {
+      reply.status(409).send({ detail: 'Username exists' });
+      return;
+    }
+    const count = await dbRequest('getCount');
+    if (count >= MAX_USERS) {
+      reply.status(507).send({ detail: 'Server full' });
+      return;
+    }
+    const userId = generateId();
+    const newUser = {
+      id: userId,
+      username: cleanUsername,
+      password_hash: hashPassword(password),
+      name: name.trim(),
+      created_at: new Date().toISOString(),
+      is_login: 0,
+      bio: '',
+      pic_url: '',
+      date_of_birth: '',
+      is_profile_public: 'true'
+    };
+    try {
+      await dbRequest('insertUser', { user: newUser });
+      totalUsers = count + 1;
+      await checkUserCountStatus();
+      reply.send({ success: true, user_id: userId, username: cleanUsername });
+    } catch (e) {
+      reply.status(500).send({ detail: 'Signup failed' });
+    }
+  });
+  
+  fastify.post('/login', async (request, reply) => {
+    const { username, password } = request.body || {};
+    if (!username || !password) {
+      reply.status(400).send({ detail: 'Missing fields' });
+      return;
+    }
+    const cleanUsername = username.trim().toLowerCase();
+    const user = await dbRequest('getUserByUsername', { username: cleanUsername });
+    if (!user) {
+      reply.status(401).send({ detail: 'Invalid credentials' });
+      return;
+    }
+    if (!verifyPassword(password, user.password_hash)) {
+      reply.status(401).send({ detail: 'Invalid credentials' });
+      return;
+    }
+    await dbRequest('updateLogin', { userId: user.id, isLogin: true });
+    reply.send({ 
+      success: true, 
+      id: user.id, 
+      username: user.username, 
+      name: user.name, 
+      bio: user.bio || '', 
+      pic_url: user.pic_url || '', 
+      date_of_birth: user.date_of_birth || '', 
+      is_profile_public: user.is_profile_public || 'true', 
+      created_at: user.created_at 
     });
+  });
+  
+  fastify.post('/logout', async (request, reply) => {
+    const { id } = request.body || {};
+    if (!id) {
+      reply.status(400).send({ detail: 'Missing ID' });
+      return;
+    }
+    const user = await dbRequest('getUserById', { userId: id });
+    if (!user) {
+      reply.status(404).send({ detail: 'Not found' });
+      return;
+    }
+    await dbRequest('updateLogin', { userId: id, isLogin: false });
+    reply.send({ success: true });
+  });
+  
+  fastify.put('/updateprofiledetails', async (request, reply) => {
+    const { id, username, name, bio, date_of_birth, is_profile_public } = request.body || {};
     
-    fastify.post('/signup', async (request, reply) => {
-        const { username, password, name } = request.body || {};
-        if (!username || !password || !name) {
-            reply.status(400).send({ detail: 'Missing fields' });
-            return;
-        }
-        
-        const cleanUsername = username.trim().toLowerCase();
-        if (cleanUsername.length < 3 || cleanUsername.length > MAX_USERNAME_LENGTH) {
-            reply.status(400).send({ detail: `Username must be 3-${MAX_USERNAME_LENGTH} chars` });
-            return;
-        }
-        if (password.length < 6 || password.length > MAX_PASSWORD_LENGTH) {
-            reply.status(400).send({ detail: `Password must be 6-${MAX_PASSWORD_LENGTH} chars` });
-            return;
-        }
-        if (name.trim().length > MAX_NAME_LENGTH) {
-            reply.status(400).send({ detail: `Name max ${MAX_NAME_LENGTH} chars` });
-            return;
-        }
-        
-        // Check if username exists directly in DB
+    if (!id) {
+      reply.status(400).send({ detail: 'Missing ID' });
+      return;
+    }
+    
+    const user = await dbRequest('getUserById', { userId: id });
+    if (!user) {
+      reply.status(404).send({ detail: 'Not found' });
+      return;
+    }
+    
+    if (name && name.length > MAX_NAME_LENGTH) {
+      reply.status(400).send({ detail: `Name max ${MAX_NAME_LENGTH} chars` });
+      return;
+    }
+    
+    if (bio && bio.length > MAX_BIO_LENGTH) {
+      reply.status(400).send({ detail: `Bio max ${MAX_BIO_LENGTH} chars` });
+      return;
+    }
+    
+    let cleanUsername = '';
+    if (username && username.trim() !== '') {
+      cleanUsername = username.trim().toLowerCase();
+      
+      if (cleanUsername.length < 3 || cleanUsername.length > MAX_USERNAME_LENGTH) {
+        reply.status(400).send({ detail: `Username must be 3-${MAX_USERNAME_LENGTH} chars` });
+        return;
+      }
+      
+      if (cleanUsername !== user.username) {
         const existingUser = await dbRequest('getUserByUsername', { username: cleanUsername });
         if (existingUser) {
-            reply.status(409).send({ detail: 'Username exists' });
-            return;
-        }
-        
-        const count = await dbRequest('getCount');
-        if (count >= MAX_USERS) {
-            reply.status(507).send({ detail: 'Server full' });
-            return;
-        }
-        
-        const userId = generateId();
-        const newUser = {
-            id: userId,
-            username: cleanUsername,
-            password_hash: hashPassword(password),
-            name: name.trim(),
-            created_at: new Date().toISOString(),
-            is_login: 0,
-            bio: '',
-            pic_url: '',
-            date_of_birth: '',
-            is_profile_public: 'true'
-        };
-        
-        try {
-            await dbRequest('insertUser', { user: newUser });
-            totalUsers = count + 1;
-            await checkUserCountStatus();
-            reply.send({ success: true, user_id: userId, username: cleanUsername });
-        } catch (e) {
-            reply.status(500).send({ detail: 'Signup failed' });
+          reply.status(409).send({ detail: 'Username exists' });
+          return;
         }
-    });
+      }
+    }
     
-    fastify.post('/login', async (request, reply) => {
-        const { username, password } = request.body || {};
-        if (!username || !password) {
-            reply.status(400).send({ detail: 'Missing fields' });
-            return;
-        }
-        
-        const cleanUsername = username.trim().toLowerCase();
-        const user = await dbRequest('getUserByUsername', { username: cleanUsername });
-        
-        if (!user) {
-            reply.status(401).send({ detail: 'Invalid credentials' });
-            return;
-        }
-        
-        if (!verifyPassword(password, user.password_hash)) {
-            reply.status(401).send({ detail: 'Invalid credentials' });
-            return;
-        }
-        
-        await dbRequest('updateLogin', { userId: user.id, isLogin: true });
-        
-        reply.send({
-            success: true,
-            id: user.id,
-            username: user.username,
-            name: user.name,
-            bio: user.bio || '',
-            pic_url: user.pic_url || '',
-            date_of_birth: user.date_of_birth || '',
-            is_profile_public: user.is_profile_public || 'true',
-            created_at: user.created_at
-        });
+    await dbRequest('updateProfile', { 
+      userId: id, 
+      username: cleanUsername,
+      name: name || '',
+      bio: bio !== undefined ? bio : '',
+      date_of_birth: date_of_birth || '',
+      is_profile_public: is_profile_public || 'true'
     });
     
-    fastify.post('/logout', async (request, reply) => {
-        const { id } = request.body || {};
-        if (!id) {
-            reply.status(400).send({ detail: 'Missing ID' });
-            return;
-        }
-        
-        const user = await dbRequest('getUserById', { userId: id });
-        if (!user) {
-            reply.status(404).send({ detail: 'Not found' });
-            return;
-        }
-        
-        await dbRequest('updateLogin', { userId: id, isLogin: false });
-        reply.send({ success: true });
-    });
-    
-    fastify.put('/updateprofiledetails', async (request, reply) => {
-  const { id, username, name, bio, date_of_birth, is_profile_public } = request.body || {};
-  
-  if (!id) {
-    reply.status(400).send({ detail: 'Missing ID' });
-    return;
-  }
-  
-  const user = await dbRequest('getUserById', { userId: id });
-  if (!user) {
-    reply.status(404).send({ detail: 'Not found' });
-    return;
-  }
-  
-  if (name && name.length > MAX_NAME_LENGTH) {
-    reply.status(400).send({ detail: `Name max ${MAX_NAME_LENGTH} chars` });
-    return;
-  }
-  
-  if (bio && bio.length > MAX_BIO_LENGTH) {
-    reply.status(400).send({ detail: `Bio max ${MAX_BIO_LENGTH} chars` });
-    return;
-  }
+    reply.send({ success: true });
+  });
   
-  let cleanUsername = null;
-  if (username && username.trim() !== '') {
-    cleanUsername = username.trim().toLowerCase();
-    
-    if (cleanUsername.length < 3 || cleanUsername.length > MAX_USERNAME_LENGTH) {
-      reply.status(400).send({ detail: `Username must be 3-${MAX_USERNAME_LENGTH} chars` });
+  fastify.post('/uploadphoto', async (request, reply) => {
+    if (getBucketSize() >= MAX_BUCKET_SIZE) {
+      reply.status(507).send({ detail: 'Storage full' });
       return;
     }
-    
-    if (cleanUsername !== user.username) {
-      const existingUser = await dbRequest('getUserByUsername', { username: cleanUsername });
-      if (existingUser) {
-        reply.status(409).send({ detail: 'Username exists' });
+    try {
+      const data = await request.file();
+      if (!data || !data.mimetype.startsWith('image/')) {
+        reply.status(400).send({ detail: 'Invalid image' });
         return;
       }
-    } else {
-      cleanUsername = null;
+      const fileBuffer = await data.toBuffer();
+      const id = (data.fields && data.fields.id) ? data.fields.id.value : null;
+      const user = await dbRequest('getUserById', { userId: id });
+      if (!id || !user) {
+        reply.status(404).send({ detail: 'Not found' });
+        return;
+      }
+      const compressed = await compressToWebp(fileBuffer, MAX_PHOTO_SIZE_KB);
+      const filename = `${id}_${Math.floor(Date.now() / 1000)}.webp`;
+      await fsp.writeFile(path.join(PHOTOS_DIR, filename), compressed);
+      await dbRequest('updatePhoto', { userId: id, picUrl: `/photos/${filename}` });
+      reply.send({ success: true });
+    } catch (e) {
+      reply.status(500).send({ detail: 'Failed' });
     }
-  }
-  
-  await dbRequest('updateProfile', { 
-    userId: id, 
-    username: cleanUsername,
-    name: name || user.name,
-    bio: bio !== undefined ? bio : user.bio,
-    date_of_birth: date_of_birth || user.date_of_birth,
-    is_profile_public: is_profile_public || user.is_profile_public
   });
   
-  reply.send({ success: true });
-});
-    
-    fastify.post('/uploadphoto', async (request, reply) => {
-        if (getBucketSize() >= MAX_BUCKET_SIZE) {
-            reply.status(507).send({ detail: 'Storage full' });
-            return;
-        }
-        
-        try {
-            const data = await request.file();
-            if (!data || !data.mimetype.startsWith('image/')) {
-                reply.status(400).send({ detail: 'Invalid image' });
-                return;
-            }
-            
-            const fileBuffer = await data.toBuffer();
-            const id = (data.fields && data.fields.id) ? data.fields.id.value : null;
-            
-            const user = await dbRequest('getUserById', { userId: id });
-            if (!id || !user) {
-                reply.status(404).send({ detail: 'Not found' });
-                return;
-            }
-            
-            const compressed = await compressToWebp(fileBuffer, MAX_PHOTO_SIZE_KB);
-            const filename = `${id}_${Math.floor(Date.now() / 1000)}.webp`;
-            await fsp.writeFile(path.join(PHOTOS_DIR, filename), compressed);
-            
-            await dbRequest('updatePhoto', { userId: id, picUrl: `/photos/${filename}` });
-            reply.send({ success: true });
-        } catch (e) {
-            reply.status(500).send({ detail: 'Failed' });
-        }
-    });
-    
-    fastify.get('/getuser', async (request, reply) => {
-        const { id, username } = request.query || {};
-        let user;
-        
-        if (username) {
-            user = await dbRequest('getUserByUsername', { username: username.toLowerCase() });
-        } else if (id) {
-            user = await dbRequest('getUserById', { userId: id });
-        } else {
-            reply.status(400).send({ detail: 'Missing params' });
-            return;
-        }
-        
-        if (!user) {
-            reply.status(404).send({ detail: 'Not found' });
-            return;
-        }
-        
-        reply.send({
-            id: user.id,
-            username: user.username,
-            name: user.name,
-            bio: user.bio || '',
-            pic_url: user.pic_url || '',
-            date_of_birth: user.date_of_birth || '',
-            is_profile_public: user.is_profile_public || 'true',
-            created_at: user.created_at,
-            is_login: Boolean(user.is_login)
-        });
+  fastify.get('/getuser', async (request, reply) => {
+    const { id, username } = request.query || {};
+    let user;
+    if (username) {
+      user = await dbRequest('getUserByUsername', { username: username.toLowerCase() });
+    } else if (id) {
+      user = await dbRequest('getUserById', { userId: id });
+    } else {
+      reply.status(400).send({ detail: 'Missing params' });
+      return;
+    }
+    if (!user) {
+      reply.status(404).send({ detail: 'Not found' });
+      return;
+    }
+    reply.send({ 
+      id: user.id, 
+      username: user.username, 
+      name: user.name, 
+      bio: user.bio || '', 
+      pic_url: user.pic_url || '', 
+      date_of_birth: user.date_of_birth || '', 
+      is_profile_public: user.is_profile_public || 'true', 
+      created_at: user.created_at, 
+      is_login: Boolean(user.is_login) 
     });
-    
-    fastify.get('/check', async (request, reply) => {
-        const count = await dbRequest('getCount');
-        reply.send({
-            status: 'ok',
-            count: count,
-            maxUsers: MAX_USERS,
-            isFull: count >= MAX_USERS,
-            spaceName: SPACE_NAME
-        });
+  });
+  
+  fastify.get('/check', async (request, reply) => {
+    const count = await dbRequest('getCount');
+    reply.send({ 
+      status: 'ok', 
+      count: count, 
+      maxUsers: MAX_USERS, 
+      isFull: count >= MAX_USERS, 
+      spaceName: SPACE_NAME 
     });
-    
-    return fastify;
+  });
+  
+  return fastify;
 }
 
 async function start() {
-    try {
-        await initDBWorker();
-        
-        // Get initial count
-        totalUsers = await dbRequest('getCount');
-        
-        await setupFastify();
-        
-        setInterval(() => {
-            checkRPSStatus();
-        }, 100);
-        
-        setInterval(async () => {
-            await checkUserCountStatus();
-        }, 5000);
-        
-        const port = process.env.PORT || 7860;
-        await fastify.listen({ port, host: '0.0.0.0' });
-        console.log(`Server running on port ${port}`);
-    } catch (err) {
-        console.error('Startup error:', err.message);
-        process.exit(1);
-    }
+  try {
+    await initDBWorker();
+    totalUsers = await dbRequest('getCount');
+    await setupFastify();
+    setInterval(() => { checkRPSStatus(); }, 100);
+    setInterval(async () => { await checkUserCountStatus(); }, 5000);
+    const port = process.env.PORT || 7860;
+    await fastify.listen({ port, host: '0.0.0.0' });
+    console.log(`Server running on port ${port}`);
+  } catch (err) {
+    console.error('Startup error:', err.message);
+    process.exit(1);
+  }
 }
 
 process.on('SIGTERM', async () => {
-    await removeSpaceFromFull();
-    await fastify.close();
-    if (dbWorker) await dbWorker.terminate();
-    process.exit(0);
+  await removeSpaceFromFull();
+  await fastify.close();
+  if (dbWorker) await dbWorker.terminate();
+  process.exit(0);
 });
 
 process.on('SIGINT', async () => {
-    await removeSpaceFromFull();
-    await fastify.close();
-    if (dbWorker) await dbWorker.terminate();
-    process.exit(0);
+  await removeSpaceFromFull();
+  await fastify.close();
+  if (dbWorker) await dbWorker.terminate();
+  process.exit(0);
 });
 
 start().catch(err => process.exit(1));