src/service/ArchiveService.ts

import { systemPrefix } from "@sudobot/utils/utils";
import { existsSync } from "fs";
import ArchiveServer from "src/server/ArchiveServer";
import { ArchiveMessagePayload } from "../types/ArchiveMessagePayload";

class ArchiveService implements Disposable {
    private _db?: Awaited<ReturnType<typeof ArchiveService.createDatabase>>;
    private _server?: ArchiveServer;

    private constructor() {}

    public get db() {
        if (!this._db) {
            throw new Error("Database not initialized");
        }

        return this._db;
    }

    private prepare(query: string, params: string[], results = true) {
        const db = this.db as unknown as import("bun:sqlite").Database;
        const compiled = db.prepare(query, params);

        if (results) {
            return compiled.all();
        }

        compiled.run();
    }

    private static createTables(_db: Awaited<ReturnType<typeof ArchiveService.createDatabase>>) {
        const db = _db as unknown as import("bun:sqlite").Database;

        db.transaction(() => {
            db.run(
                `CREATE TABLE IF NOT EXISTS messages (
                    id TEXT PRIMARY KEY,
                    userId TEXT,
                    guildId TEXT,
                    channelId TEXT,
                    content TEXT,
                    timestamp INTEGER
                );
                `
            );

            db.run(`
                CREATE TABLE IF NOT EXISTS users (
                    id TEXT PRIMARY KEY,
                    username TEXT,
                    isBot INTEGER DEFAULT 0
                );`);
        })();
    }

    public async archive({ author, guild, message, channel }: ArchiveMessagePayload) {
        const { id: userId } = author;
        const { id: guildId } = guild;
        const { id: channelId } = channel;
        const { id, content, createdTimestamp } = message;

        this.prepare(
            `INSERT INTO messages (id, userId, guildId, channelId, content, timestamp) VALUES (?, ?, ?, ?, ?, ?);`,
            [id, userId, guildId, channelId, content, createdTimestamp.toString()],
            false
        );

        this.prepare(
            `INSERT OR IGNORE INTO users (id, username, isBot) VALUES (?, ?, ?);`,
            [userId, author.username, author.bot ? "1" : "0"],
            false
        );
    }

    public close() {
        this._db?.close();
    }

    public static async create() {
        const service = new ArchiveService();
        service._db = await ArchiveService.createDatabase();
        service._server = new ArchiveServer(service._db);
        return service;
    }

    private static async createDatabase() {
        let db;
        const dbPath = systemPrefix("archive.db");
        const createTables = !existsSync(dbPath);

        if (process.isBun) {
            const { Database } = await import("bun:sqlite");
            db = new Database(dbPath, {
                create: true,
                strict: true,
                readwrite: true
            });
        } else {
            const { default: Database } = await import("better-sqlite3");
            db = new Database(dbPath);
        }

        if (createTables) {
            this.createTables(db);
        }

        return db;
    }

    public [Symbol.dispose]() {
        this.close();
    }

    public startServer() {
        this._server?.start();
    }
}

export default ArchiveService;
1	rakinar2	632	import { systemPrefix } from "@sudobot/utils/utils";
2			import { existsSync } from "fs";
3			import ArchiveServer from "src/server/ArchiveServer";
4			import { ArchiveMessagePayload } from "../types/ArchiveMessagePayload";
5
6			class ArchiveService implements Disposable {
7			private _db?: Awaited<ReturnType<typeof ArchiveService.createDatabase>>;
8			private _server?: ArchiveServer;
9
10			private constructor() {}
11
12			public get db() {
13			if (!this._db) {
14			throw new Error("Database not initialized");
15			}
16
17			return this._db;
18			}
19
20			private prepare(query: string, params: string[], results = true) {
21			const db = this.db as unknown as import("bun:sqlite").Database;
22			const compiled = db.prepare(query, params);
23
24			if (results) {
25			return compiled.all();
26			}
27
28			compiled.run();
29			}
30
31			private static createTables(_db: Awaited<ReturnType<typeof ArchiveService.createDatabase>>) {
32			const db = _db as unknown as import("bun:sqlite").Database;
33
34			db.transaction(() => {
35			db.run(
36			`CREATE TABLE IF NOT EXISTS messages (
37			id TEXT PRIMARY KEY,
38			userId TEXT,
39			guildId TEXT,
40			channelId TEXT,
41			content TEXT,
42			timestamp INTEGER
43			);
44			`
45			);
46
47			db.run(`
48			CREATE TABLE IF NOT EXISTS users (
49			id TEXT PRIMARY KEY,
50			username TEXT,
51			isBot INTEGER DEFAULT 0
52			);`);
53			})();
54			}
55
56			public async archive({ author, guild, message, channel }: ArchiveMessagePayload) {
57			const { id: userId } = author;
58			const { id: guildId } = guild;
59			const { id: channelId } = channel;
60			const { id, content, createdTimestamp } = message;
61
62			this.prepare(
63			`INSERT INTO messages (id, userId, guildId, channelId, content, timestamp) VALUES (?, ?, ?, ?, ?, ?);`,
64			[id, userId, guildId, channelId, content, createdTimestamp.toString()],
65			false
66			);
67
68			this.prepare(
69			`INSERT OR IGNORE INTO users (id, username, isBot) VALUES (?, ?, ?);`,
70			[userId, author.username, author.bot ? "1" : "0"],
71			false
72			);
73			}
74
75			public close() {
76			this._db?.close();
77			}
78
79			public static async create() {
80			const service = new ArchiveService();
81			service._db = await ArchiveService.createDatabase();
82			service._server = new ArchiveServer(service._db);
83			return service;
84			}
85
86			private static async createDatabase() {
87			let db;
88			const dbPath = systemPrefix("archive.db");
89			const createTables = !existsSync(dbPath);
90
91			if (process.isBun) {
92			const { Database } = await import("bun:sqlite");
93			db = new Database(dbPath, {
94			create: true,
95			strict: true,
96			readwrite: true
97			});
98			} else {
99			const { default: Database } = await import("better-sqlite3");
100			db = new Database(dbPath);
101			}
102
103			if (createTables) {
104			this.createTables(db);
105			}
106
107			return db;
108			}
109
110			public [Symbol.dispose]() {
111			this.close();
112			}
113
114			public startServer() {
115			this._server?.start();
116			}
117			}
118
119			export default ArchiveService;