brainz-social-old/database-handler.js

const db = require("better-sqlite3")("brainz-social.db");
db.pragma("journal_mode = WAL");

module.exports = {
    db,

    getConfig: (key) => {
        const row = db.prepare("SELECT * FROM config WHERE key = ?").get(key);
        return row ? row.value : null;
    },

    setConfig: (key, value) => {
        db.prepare("INSERT OR REPLACE INTO config (key, value) VALUES(?, ?);").run(key, value);
    },

    createApplication: (client_name, redirect_uri, scopes, website, client_id, client_secret) => {
        db.prepare("INSERT INTO applications (client_name, redirect_uri, scopes, website, client_id, client_secret) VALUES (?, ?, ?, ?, ?, ?);").run(client_name, redirect_uri, scopes, website, client_id, client_secret);
    },

    getApplication: (client_id) => {
        return db.prepare("SELECT id, client_id, client_secret, redirect_uri, scopes, website FROM applications WHERE client_id = ?").get(client_id);
    },

    getApplicationById: (id) => {
        return db.prepare("SELECT id, client_id, client_secret, redirect_uri, scopes, website FROM applications WHERE id = ?").get(id);
    },

    createToken: (token, scope, application_id, user_id, created_at) => {
        db.prepare("INSERT INTO oauth_tokens (token, scopes, application_id, user_id, created_at, revoked) VALUES (?, ?, ?, ?, ?, false)").run(token, scope, application_id, user_id, created_at);
    },

    getTokenData: (token) => {
        return db.prepare("SELECT application_id, user_id, created_at, revoked FROM oauth_tokens WHERE token = ?").get(token);
    },

    revokeToken: (token) => {
        db.prepare("UPDATE oauth_tokens SET revoked = true WHERE token = ?").run(token);
    },

    getAccountByUsername: (username) => {
        return db.prepare("SELECT id, username, email, password_hash, account_tier FROM accounts WHERE username = ?").get(username);
    },

    createAccount: (username, email, password_hash) => {
        db.prepare("INSERT INTO accounts (username, email, password_hash, account_tier) VALUES (?, ?, ?, 0)").run(username, email, password_hash);
    },

    checkAuthCookie: (cookie_value) => {
        return db.prepare("SELECT id, cookie_value, created_at, user_id, revoked FROM cookies WHERE cookie_value = ?").get(cookie_value);
    },

    revokeAuthCookie: (cookie_value) => {
        db.prepare("UPDATE cookies SET revoked = true WHERE cookie_value = ?").run(cookie_value);
    },

    createAuthCookie: (cookie_value, created_at, user_id) => {
        db.prepare("INSERT INTO cookies (cookie_value, created_at, user_id, revoked) VALUES (?, ?, ?, false)").run(cookie_value, created_at, user_id);
    },

    createCsrfToken: (url, created_at, cookie_value) => {
        const db_row_id = db.prepare("INSERT INTO csrf_token (url, created_at, cookie_value) VALUES (?, ?, ?)").run(url, created_at, cookie_value).lastInsertRowid;
        return db.prepare("SELECT id FROM csrf_token WHERE rowid = ?").get(db_row_id);
    },

    createCsrfTokenAssociation: (...ids) => {
        for ( const source_id in ids ) {
            for ( const destination_id in ids ) {
                db.prepare("INSERT INTO csrf_token_relations (source_id, destination_id) VALUES (?, ?)").run(source_id, destination_id);
            }
        }
    },

    removeAssociatedCsrfTokens: (id) => {
        db.prepare("DELETE FROM csrf_token WHERE id IN (SELECT destination_id AS id FROM csrf_token_relations WHERE source_id = ?)").run(id);
    },

    getCsrfToken: (url) => {
        return db.prepare("SELECT id, url, created_at, cookie_value FROM csrf_token WHERE url = ?").get(url);
    },

    createOauthCode: (code, application_id, user_id, scopes, created_at) => {
        db.prepare("INSERT INTO oauth_code (code, application_id, user_id, scopes, created_at, revoked) VALUES (?, ?, ?, ?, ?, false)").run(code, application_id, user_id, scopes, created_at);
    },

    getOauthCode: (code) => {
        return db.prepare("SELECT code, application_id, user_id, scopes, created_at, revoked FROM oauth_code WHERE code = ?").get(code);
    },

    revokeOauthCode: (code) => {
        db.prepare("UPDATE oauth_code SET revoked = true WHERE code = ?").run(code);
    },

    selectApplicationByAuthToken: (token) => {
        return db.prepare("SELECT id, client_id, client_secret, redirect_uri, scopes, website FROM applications WHERE id in (SELECT application_id as id FROM oauth_tokens WHERE token = ?);").get(token);
    },

    getVapidKey: () => {
        const vapidPublic = db.prepare("SELECT value FROM config WHERE key = vapid_key_public").get();
        const vapidPrivate = db.prepare("SELECT value FROM config WHERE key = vapid_key_private").get();
        if ( vapidPublic.value && vapidPrivate.value ) {
            return {public: vapidPublic, private: vapidPrivate};
        } else {
            return null;
        }
    },

    setVapidKey: (publicKey, privateKey) => {
        db.prepare("INSERT INTO config (key, value) VALUES (vapid_key_public, ?)").run(publicKey);
        db.prepare("INSERT INTO config (key, value) VALUES (vapid_key_private, ?)").run(privateKey);
    }
};