psql

src/database.ts

@@ -1,5 +1,4 @@
-import sqlite3 from 'sqlite3';
-import path from 'path';
+import { Pool, QueryResult } from 'pg';
 
 interface TelegramUser {
     id: number;
@@ -18,104 +17,91 @@ interface User {
 }
 
 export class Database {
-    private dbPath: string;
-    private db: sqlite3.Database;
+    private pool: Pool;
 
     constructor() {
-        this.dbPath = path.join(__dirname, '../database/quixotic.db');
-        this.db = new sqlite3.Database(this.dbPath);
+        const connectionString = process.env.DATABASE_URL || 'postgresql://quixotic:quixotic123@localhost:5432/quixotic';
+        this.pool = new Pool({
+            connectionString,
+            ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
+        });
         this.init();
     }
 
-    private init(): void {
-        this.db.serialize(() => {
+    private async init(): Promise<void> {
+        try {
             // Users table
-            this.db.run(`CREATE TABLE IF NOT EXISTS users (
-                id INTEGER PRIMARY KEY,
-                telegram_id INTEGER UNIQUE NOT NULL,
+            await this.pool.query(`CREATE TABLE IF NOT EXISTS users (
+                id SERIAL PRIMARY KEY,
+                telegram_id BIGINT UNIQUE NOT NULL,
                 username TEXT,
                 first_name TEXT,
                 last_name TEXT,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
             )`);
 
             // Search history table
-            this.db.run(`CREATE TABLE IF NOT EXISTS search_history (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id INTEGER,
+            await this.pool.query(`CREATE TABLE IF NOT EXISTS search_history (
+                id SERIAL PRIMARY KEY,
+                user_id INTEGER REFERENCES users(id),
                 query TEXT NOT NULL,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (user_id) REFERENCES users (id)
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
             )`);
 
             // Downloaded files table
-            this.db.run(`CREATE TABLE IF NOT EXISTS downloads (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id INTEGER,
+            await this.pool.query(`CREATE TABLE IF NOT EXISTS downloads (
+                id SERIAL PRIMARY KEY,
+                user_id INTEGER REFERENCES users(id),
                 youtube_id TEXT NOT NULL,
                 title TEXT NOT NULL,
                 file_path TEXT,
-                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (user_id) REFERENCES users (id)
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
             )`);
-        });
+        } catch (error) {
+            console.error('Database initialization error:', error);
+        }
     }
 
-    addUser(telegramUser: TelegramUser): Promise<number> {
-        return new Promise((resolve, reject) => {
-            const { id, username, first_name, last_name } = telegramUser;
-            this.db.run(
-                `INSERT OR REPLACE INTO users (telegram_id, username, first_name, last_name) 
-                 VALUES (?, ?, ?, ?)`,
-                [id, username, first_name, last_name],
-                function(err: Error | null) {
-                    if (err) reject(err);
-                    else resolve(this.lastID);
-                }
-            );
-        });
+    async addUser(telegramUser: TelegramUser): Promise<number> {
+        const { id, username, first_name, last_name } = telegramUser;
+        const result = await this.pool.query(
+            `INSERT INTO users (telegram_id, username, first_name, last_name) 
+             VALUES ($1, $2, $3, $4)
+             ON CONFLICT (telegram_id) DO UPDATE SET
+             username = EXCLUDED.username,
+             first_name = EXCLUDED.first_name,
+             last_name = EXCLUDED.last_name
+             RETURNING id`,
+            [id, username, first_name, last_name]
+        );
+        return result.rows[0].id;
     }
 
-    addSearchHistory(userId: number, query: string): Promise<number> {
-        return new Promise((resolve, reject) => {
-            this.db.run(
-                'INSERT INTO search_history (user_id, query) VALUES (?, ?)',
-                [userId, query],
-                function(err: Error | null) {
-                    if (err) reject(err);
-                    else resolve(this.lastID);
-                }
-            );
-        });
+    async addSearchHistory(userId: number, query: string): Promise<number> {
+        const result = await this.pool.query(
+            'INSERT INTO search_history (user_id, query) VALUES ($1, $2) RETURNING id',
+            [userId, query]
+        );
+        return result.rows[0].id;
     }
 
-    addDownload(userId: number, youtubeId: string, title: string, filePath: string): Promise<number> {
-        return new Promise((resolve, reject) => {
-            this.db.run(
-                'INSERT INTO downloads (user_id, youtube_id, title, file_path) VALUES (?, ?, ?, ?)',
-                [userId, youtubeId, title, filePath],
-                function(err: Error | null) {
-                    if (err) reject(err);
-                    else resolve(this.lastID);
-                }
-            );
-        });
+    async addDownload(userId: number, youtubeId: string, title: string, filePath: string): Promise<number> {
+        const result = await this.pool.query(
+            'INSERT INTO downloads (user_id, youtube_id, title, file_path) VALUES ($1, $2, $3, $4) RETURNING id',
+            [userId, youtubeId, title, filePath]
+        );
+        return result.rows[0].id;
     }
 
-    getUserByTelegramId(telegramId: string | number): Promise<User | undefined> {
-        return new Promise((resolve, reject) => {
-            this.db.get(
-                'SELECT * FROM users WHERE telegram_id = ?',
-                [telegramId],
-                (err: Error | null, row: User) => {
-                    if (err) reject(err);
-                    else resolve(row);
-                }
-            );
-        });
+    async getUserByTelegramId(telegramId: string | number): Promise<User | undefined> {
+        const result = await this.pool.query(
+            'SELECT * FROM users WHERE telegram_id = $1',
+            [telegramId]
+        );
+        return result.rows[0] || undefined;
     }
 
-    close(): void {
-        this.db.close();
+    async close(): Promise<void> {
+        await this.pool.end();
     }
 }