src/client/Database.ts

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

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);
            }
        });
    }

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