litemap/build/litemap/DatabaseManager/UserDatabaseManager.js

A TypeScript library for mapping and processing data with SQLite integration

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const SQLiteDatabase_1 = __importDefault(require("../SQLitedb/SQLiteDatabase"));
class DatabaseQueue {
    constructor() {
        this.queue = [];
        this.isProcessing = false;
    }
    enqueue(operation) {
        return new Promise((resolve, reject) => {
            this.queue.push({ operation, resolve, reject });
            this.processQueue();
        });
    }
    async processQueue() {
        if (this.isProcessing || this.queue.length === 0)
            return;
        this.isProcessing = true;
        const { operation, resolve, reject } = this.queue.shift();
        try {
            const result = await operation();
            resolve(result);
        }
        catch (error) {
            reject(error);
        }
        finally {
            this.isProcessing = false;
            this.processQueue();
        }
    }
}
class UserDatabaseManager {
    constructor(filename = "./db/database.db") {
        this.USER_NAMESPACE = "users/";
        this.ITEM_NAMESPACE = "items/";
        this.db = new SQLiteDatabase_1.default(filename);
        this.queue = new DatabaseQueue();
    }
    withItemNamespace(key) {
        return `${this.ITEM_NAMESPACE}${key}`;
    }
    withUserNamespace(key) {
        return `${this.USER_NAMESPACE}${key}`;
    }
    async addItems(data) {
        return this.queue.enqueue(async () => {
            if (Array.isArray(data)) {
                const namespacedRecords = data.map(({ key, value }) => ({
                    key: this.withItemNamespace(key),
                    value,
                }));
                await this.db.batchSetItems(namespacedRecords);
            }
            else {
                const records = Object.entries(data).map(([key, value]) => ({
                    key: this.withItemNamespace(key),
                    value,
                }));
                await this.db.batchSetItems(records);
            }
        });
    }
    async addUsers(data) {
        return this.queue.enqueue(async () => {
            if (Array.isArray(data)) {
                const namespacedRecords = data.map(({ key, value }) => ({
                    key: this.withUserNamespace(key),
                    value,
                }));
                await this.db.batchSetUsers(namespacedRecords);
            }
            else {
                const records = Object.entries(data).map(([key, value]) => ({
                    key: this.withUserNamespace(key),
                    value,
                }));
                await this.db.batchSetUsers(records);
            }
        });
    }
    async updateUser(key, value) {
        return this.queue.enqueue(async () => {
            await this.db.append(this.withUserNamespace(key), value);
        });
    }
    async getUser(key) {
        return this.queue.enqueue(async () => {
            return await this.db.get(this.withUserNamespace(key));
        });
    }
    async getAllUserKeys() {
        return this.queue.enqueue(async () => {
            const keys = await this.db.getAllKeys(this.USER_NAMESPACE);
            return keys.map((key) => key.replace(this.USER_NAMESPACE, ""));
        });
    }
    async getRawDataMap() {
        return this.queue.enqueue(async () => {
            const rawData = await this.db.getRawDataMap();
            const userMap = {};
            for (const key in rawData) {
                if (key.startsWith(this.USER_NAMESPACE)) {
                    const userKey = key.replace(this.USER_NAMESPACE, "");
                    userMap[userKey] = rawData[key];
                }
            }
            return userMap;
        });
    }
    async deleteUser(key) {
        return this.queue.enqueue(async () => {
            return await this.db.delete(this.withUserNamespace(key));
        });
    }
    async clearUsers() {
        return this.queue.enqueue(async () => {
            await this.db.clear();
        });
    }
    async close() {
        return this.queue.enqueue(async () => {
            await this.db.close();
        });
    }
}
exports.default = UserDatabaseManager;