rauth/engines/SQLiteEngine.js

Authentication and Authorization library via JWT

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const os_1 = __importDefault(require("os"));
// @ts-ignore
const sqlite_1 = require("sqlite");
const ConnectionStore_1 = require("../store/ConnectionStore");
const uuid = require("uuid");
const ow_1 = __importDefault(require("ow"));
class SQLiteEngine {
    constructor(option = {}) {
        const filename = option.filename || `${os_1.default.tmpdir()}/db.sqlite`;
        this.table = option.table || 'sessions';
        this.sqlite = sqlite_1.open(filename, {
            promise: Promise,
            cached: true,
        })
            .then(async (db) => {
            await db.run(`CREATE TABLE IF NOT EXISTS ${this.table} (
          id INT PRIMARY KEY,
          sessionId TEXT UNIQUE,
          userId TEXT,
          createdAt SMALLDATETIME,
          scope TEXT,
          data TEXT,
          refreshAt SMALLDATETIME
        );`);
            return db;
        });
    }
    async deleteById(sessionId) {
        const db = await this.sqlite;
        await db.run(`DELETE FROM ${this.table} WHERE sessionId = $sessionId`, {
            $sessionId: sessionId,
        });
        return true;
    }
    async deleteByUserId(userId) {
        const db = await this.sqlite;
        await db.run(`DELETE FROM ${this.table} WHERE userId = $userId`, {
            $userId: userId,
        });
        return true;
    }
    async deleteByIds(sessionIds) {
        const results = await Promise.all(sessionIds.map(sessionId => this.deleteById(sessionId)));
        return results.every(result => result);
    }
    async update(register, sets) {
        if (!register.sessionId)
            return register;
        const db = await this.sqlite;
        ow_1.default(sets.refreshAt, 'sets.refreshAt', ow_1.default.number);
        await db.run(`UPDATE ${this.table}
      SET refreshAt = $refreshAt
      WHERE sessionId = $sessionId`, {
            $refreshAt: sets.refreshAt,
            $sessionId: register.sessionId,
        });
        return this.findById(register.sessionId);
    }
    async findById(sessionId) {
        const db = await this.sqlite;
        const result = await db.get(`SELECT * FROM ${this.table} WHERE sessionId = $sessionId;`, { $sessionId: sessionId });
        if (!result) {
            throw new Error('Register was not created');
        }
        const { data, ...res } = result;
        return {
            ...res,
            data: JSON.parse(data),
        };
    }
    async findByUserId(userId) {
        const db = await this.sqlite;
        const results = await db.all(`SELECT * FROM ${this.table} WHERE userId = $userId;`, { $userId: userId });
        return results.map((result) => {
            const { data, ...res } = result;
            return {
                ...res,
                data: JSON.parse(data),
            };
        });
    }
    async create(sessionRegister) {
        const db = await this.sqlite;
        const sessionId = uuid();
        await db.run(`INSERT INTO ${this.table}
      VALUES (
        $id,
        $sessionId,
        $userId,
        $createdAt,
        $scope,
        $data,
        $refreshAt
      );`, {
            $id: Date.now(),
            $sessionId: sessionId,
            $userId: sessionRegister.userId,
            $createdAt: Date.now(),
            $scope: sessionRegister.scope,
            $data: JSON.stringify(sessionRegister.data),
            $refreshAt: Date.now(),
        });
        const register = await this.findById(sessionId);
        if (!register) {
            throw new Error('Register was not created');
        }
        return register;
    }
}
exports.SQLiteEngine = SQLiteEngine;
// Default engines
ConnectionStore_1.ConnectionStore.add('SQLite', SQLiteEngine);
//# sourceMappingURL=SQLiteEngine.js.map