src/client/Database.ts

import { Sequelize } from 'sequelize';
import { Database as DB } from 'sqlite3';
import DiscordClient from './Client';
import mongoose from "mongoose";

export default class Database {
    client: DiscordClient;
    dbpath: string;
    db: DB;
    sequelize: Sequelize;

    constructor(dbpath: string, client: DiscordClient) {
        this.client = client;
        this.dbpath = dbpath;

        this.sequelize = new Sequelize({
            dialect: 'sqlite',
            storage: dbpath,
        });

        this.db = new DB(dbpath, (err) => {
            if (err) {
                console.log(err);
            }
        });

        mongoose.connect(process.env.MONGO_URI!)
            .then(() => console.log("Connected to MongoDB"))
            .catch(console.error);
    }

    get(sql: string, params: any[] | Function, callback?: Function) {
        return this.db.get(sql, params, callback);
    }

    all(sql: string, params: any[] | Function, callback?: Function) {
        return this.db.all(sql, params, callback);
    }

    runAsync(sql: string, paramsOrCallback: any[] | Function = []) {
        return new Promise<void>((resolve, reject) => {
            this.db.run(sql, paramsOrCallback, err => {
                if (err) {
                    reject(err);
                    return;
                }

                resolve();
            });
        });
    }

    getAsync(sql: string, paramsOrCallback: any[] | Function = []): Promise <any> {
        return new Promise((resolve, reject) => {
            this.db.get(sql, paramsOrCallback, (err, data) => {
                if (err) {
                    reject(err);
                    return;
                }

                resolve(data);
            });
        });
    }

    allAsync(sql: string, paramsOrCallback: any[] | Function = []): Promise <any> {
        return new Promise((resolve, reject) => {
            this.db.all(sql, paramsOrCallback, (err, data) => {
                if (err) {
                    reject(err);
                    return;
                }

                resolve(data);
            });
        });
    }

    get s(): Sequelize {
        return this.sequelize;
    }
};
1	import { Sequelize } from 'sequelize';
2	import { Database as DB } from 'sqlite3';
3	import DiscordClient from './Client';
4	import mongoose from "mongoose";
5
6	export default class Database {
7	client: DiscordClient;
8	dbpath: string;
9	db: DB;
10	sequelize: Sequelize;
11
12	constructor(dbpath: string, client: DiscordClient) {
13	this.client = client;
14	this.dbpath = dbpath;
15
16	this.sequelize = new Sequelize({
17	dialect: 'sqlite',
18	storage: dbpath,
19	});
20
21	this.db = new DB(dbpath, (err) => {
22	if (err) {
23	console.log(err);
24	}
25	});
26
27	mongoose.connect(process.env.MONGO_URI!)
28	.then(() => console.log("Connected to MongoDB"))
29	.catch(console.error);
30	}
31
32	get(sql: string, params: any[] \| Function, callback?: Function) {
33	return this.db.get(sql, params, callback);
34	}
35
36	all(sql: string, params: any[] \| Function, callback?: Function) {
37	return this.db.all(sql, params, callback);
38	}
39
40	runAsync(sql: string, paramsOrCallback: any[] \| Function = []) {
41	return new Promise<void>((resolve, reject) => {
42	this.db.run(sql, paramsOrCallback, err => {
43	if (err) {
44	reject(err);
45	return;
46	}
47
48	resolve();
49	});
50	});
51	}
52
53	getAsync(sql: string, paramsOrCallback: any[] \| Function = []): Promise <any> {
54	return new Promise((resolve, reject) => {
55	this.db.get(sql, paramsOrCallback, (err, data) => {
56	if (err) {
57	reject(err);
58	return;
59	}
60
61	resolve(data);
62	});
63	});
64	}
65
66	allAsync(sql: string, paramsOrCallback: any[] \| Function = []): Promise <any> {
67	return new Promise((resolve, reject) => {
68	this.db.all(sql, paramsOrCallback, (err, data) => {
69	if (err) {
70	reject(err);
71	return;
72	}
73
74	resolve(data);
75	});
76	});
77	}
78
79	get s(): Sequelize {
80	return this.sequelize;
81	}
82	};