shogun-core 6.2.3 → 6.3.0

package/dist/src/gundb/db.js

@@ -0,0 +1,728 @@
+/**
+ * GunDB - Simplified database wrapper for Gun.js
+ * Provides only essential signup and login functionality
+ * Based on Gun.js User Authentication: https://deepwiki.com/amark/gun/6.1-user-authentication
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { RxJS } from "./rxjs.js";
+import { EventEmitter } from "../utils/eventEmitter.js";
+import * as GunErrors from "./errors.js";
+import * as crypto from "./crypto.js";
+/**
+ * Configuration constants
+ */
+var CONFIG = {
+    PASSWORD: {
+        MIN_LENGTH: 8,
+    },
+    TIMEOUT: 11000, // 30 seconds
+};
+var DataBase = /** @class */ (function () {
+    function DataBase(gun, appScope, core, sea) {
+        if (appScope === void 0) { appScope = "shogun"; }
+        var _a;
+        this.user = null;
+        this.onAuthCallbacks = [];
+        this._isDestroyed = false;
+        console.log("[DB] Initializing DataBase");
+        // Initialize event emitter
+        this.eventEmitter = new EventEmitter();
+        // Validate Gun instance
+        if (!gun) {
+            throw new Error("Gun instance is required but was not provided");
+        }
+        if (typeof gun.user !== "function") {
+            throw new Error("Gun instance is invalid: gun.user is not a function");
+        }
+        this.gun = gun;
+        console.log("[DB] Gun instance validated");
+        // Recall user session if available
+        this.user = this.gun.user().recall({ sessionStorage: true });
+        console.log("[DB] User recall completed");
+        this.subscribeToAuthEvents();
+        console.log("[DB] Auth events subscribed");
+        this.crypto = crypto;
+        // Get SEA from gun instance or global
+        this.sea = sea || null;
+        if (!this.sea) {
+            if (this.gun.SEA) {
+                this.sea = this.gun.SEA;
+            }
+            else if ((_a = globalThis.Gun) === null || _a === void 0 ? void 0 : _a.SEA) {
+                this.sea = globalThis.Gun.SEA;
+            }
+            else if (globalThis.SEA) {
+                this.sea = globalThis.SEA;
+            }
+        }
+        this._rxjs = new RxJS(this.gun);
+        this.node = this.gun.get(appScope);
+        console.log("[DB] DataBase initialization completed");
+    }
+    /**
+     * Initialize with app scope
+     */
+    DataBase.prototype.initialize = function (appScope) {
+        if (appScope === void 0) { appScope = "shogun"; }
+        console.log("[DB] Initializing with appScope: ".concat(appScope));
+        this.node = this.gun.get(appScope);
+        console.log("[DB] App scope node initialized");
+    };
+    /**
+     * Subscribe to Gun auth events
+     */
+    DataBase.prototype.subscribeToAuthEvents = function () {
+        var _this = this;
+        this.gun.on("auth", function (ack) {
+            var _a;
+            if (ack.err) {
+                console.error("[DB] Auth event error:", ack.err);
+            }
+            else {
+                _this.notifyAuthListeners(((_a = ack.sea) === null || _a === void 0 ? void 0 : _a.pub) || "");
+            }
+        });
+    };
+    /**
+     * Notify all auth callbacks
+     */
+    DataBase.prototype.notifyAuthListeners = function (pub) {
+        var user = this.gun.user();
+        this.onAuthCallbacks.forEach(function (cb) { return cb(user); });
+    };
+    /**
+     * Register authentication callback
+     */
+    DataBase.prototype.onAuth = function (callback) {
+        var _this = this;
+        this.onAuthCallbacks.push(callback);
+        var user = this.gun.user();
+        if (user && user.is)
+            callback(user);
+        return function () {
+            var i = _this.onAuthCallbacks.indexOf(callback);
+            if (i !== -1)
+                _this.onAuthCallbacks.splice(i, 1);
+        };
+    };
+    /**
+     * Check if user is logged in
+     */
+    DataBase.prototype.isLoggedIn = function () {
+        try {
+            var user = this.gun.user();
+            return !!(user && user.is && user.is.pub);
+        }
+        catch (error) {
+            return false;
+        }
+    };
+    /**
+     * Restore session from storage
+     */
+    DataBase.prototype.restoreSession = function () {
+        try {
+            if (typeof sessionStorage === "undefined") {
+                return { success: false, error: "sessionStorage not available" };
+            }
+            var sessionData = sessionStorage.getItem("gunSessionData");
+            if (!sessionData) {
+                return { success: false, error: "No saved session" };
+            }
+            var session = JSON.parse(sessionData);
+            if (!session.userPub) {
+                return { success: false, error: "Invalid session data" };
+            }
+            // Check if session is expired
+            if (session.expiresAt && Date.now() > session.expiresAt) {
+                sessionStorage.removeItem("gunSessionData");
+                return { success: false, error: "Session expired" };
+            }
+            // Verify session restoration
+            var user = this.gun.user();
+            if (user.is && user.is.pub === session.userPub) {
+                this.user = user;
+                return { success: true, userPub: session.userPub };
+            }
+            return { success: false, error: "Session verification failed" };
+        }
+        catch (error) {
+            return { success: false, error: String(error) };
+        }
+    };
+    /**
+     * Logout user
+     */
+    DataBase.prototype.logout = function () {
+        try {
+            var currentUser = this.gun.user();
+            if (currentUser && currentUser.is) {
+                currentUser.leave();
+            }
+            this.user = null;
+            if (typeof sessionStorage !== "undefined") {
+                sessionStorage.removeItem("gunSessionData");
+            }
+        }
+        catch (error) {
+            console.error("[DB] Error during logout:", error);
+        }
+    };
+    /**
+     * Validate password strength
+     */
+    DataBase.prototype.validatePasswordStrength = function (password) {
+        if (password.length < CONFIG.PASSWORD.MIN_LENGTH) {
+            return {
+                valid: false,
+                error: "Password must be at least ".concat(CONFIG.PASSWORD.MIN_LENGTH, " characters long"),
+            };
+        }
+        return { valid: true };
+    };
+    /**
+     * Validate signup credentials
+     */
+    DataBase.prototype.validateSignupCredentials = function (username, password, pair) {
+        if (!username || username.length < 1) {
+            return {
+                valid: false,
+                error: "Username must be more than 0 characters long",
+            };
+        }
+        if (!/^[a-zA-Z0-9._-]+$/.test(username)) {
+            return {
+                valid: false,
+                error: "Username can only contain letters, numbers, dots, underscores, and hyphens",
+            };
+        }
+        if (pair) {
+            if (!pair.pub || !pair.priv || !pair.epub || !pair.epriv) {
+                return { valid: false, error: "Invalid pair provided" };
+            }
+            return { valid: true };
+        }
+        return this.validatePasswordStrength(password);
+    };
+    /**
+     * Reset authentication state
+     */
+    DataBase.prototype.resetAuthState = function () {
+        try {
+            var user = this.gun.user();
+            if (user && user._) {
+                var cat = user._;
+                // Reset Gun's internal auth state
+                cat.ing = false;
+                cat.auth = null;
+                cat.act = null;
+                // Clear any pending auth operations
+                if (cat.auth) {
+                    cat.auth = null;
+                }
+            }
+            try {
+                user.leave();
+            }
+            catch (leaveError) {
+                // Ignore leave errors
+            }
+            this.user = null;
+        }
+        catch (e) {
+            // Ignore
+        }
+    };
+    /**
+     * Build login result
+     */
+    DataBase.prototype.buildLoginResult = function (username, userPub) {
+        var _a, _b;
+        var seaPair = (_b = (_a = this.gun.user()) === null || _a === void 0 ? void 0 : _a._) === null || _b === void 0 ? void 0 : _b.sea;
+        return {
+            success: true,
+            userPub: userPub,
+            username: username,
+            sea: seaPair
+                ? {
+                    pub: seaPair.pub,
+                    priv: seaPair.priv,
+                    epub: seaPair.epub,
+                    epriv: seaPair.epriv,
+                }
+                : undefined,
+        };
+    };
+    /**
+     * Save credentials to session storage
+     */
+    DataBase.prototype.saveCredentials = function (userInfo) {
+        try {
+            if (typeof sessionStorage !== "undefined") {
+                var sessionInfo = {
+                    username: userInfo.alias,
+                    pair: userInfo.pair,
+                    userPub: userInfo.userPub,
+                    timestamp: Date.now(),
+                    expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000, // 7 days
+                };
+                sessionStorage.setItem("gunSessionData", JSON.stringify(sessionInfo));
+            }
+        }
+        catch (error) {
+            console.error("[DB] Error saving credentials:", error);
+        }
+    };
+    /**
+     * Sign up a new user
+     * Based on Gun.js user().create() - https://deepwiki.com/amark/gun/6.1-user-authentication
+     */
+    DataBase.prototype.signUp = function (username, password, pair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var validation, normalizedUsername, user, loginResult, e_1, result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        validation = this.validateSignupCredentials(username, password, pair);
+                        if (!validation.valid) {
+                            return [2 /*return*/, { success: false, error: validation.error }];
+                        }
+                        console.log("[DB] Signup validation:", validation);
+                        this.resetAuthState();
+                        normalizedUsername = username.trim().toLowerCase();
+                        user = this.gun.user();
+                        if (!pair) return [3 /*break*/, 4];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                var callbackInvoked = false;
+                                var timeoutId = setTimeout(function () {
+                                    if (!callbackInvoked) {
+                                        callbackInvoked = true;
+                                        resolve({ success: false, error: "Pair auth timeout" });
+                                    }
+                                }, CONFIG.TIMEOUT);
+                                user.auth(pair, function (ack) {
+                                    var _a, _b, _c;
+                                    if (callbackInvoked) {
+                                        return;
+                                    }
+                                    callbackInvoked = true;
+                                    clearTimeout(timeoutId);
+                                    if (ack.err) {
+                                        // Could not login with pair, try to create user with username/password
+                                        resolve({ success: false, error: ack.err });
+                                        return;
+                                    }
+                                    var userPub = (_a = user === null || user === void 0 ? void 0 : user.is) === null || _a === void 0 ? void 0 : _a.pub;
+                                    if (!userPub) {
+                                        _this.resetAuthState();
+                                        resolve({ success: false, error: "No userPub available" });
+                                        return;
+                                    }
+                                    _this.user = user;
+                                    var alias = (_b = user === null || user === void 0 ? void 0 : user.is) === null || _b === void 0 ? void 0 : _b.alias;
+                                    var userPair = (_c = user === null || user === void 0 ? void 0 : user._) === null || _c === void 0 ? void 0 : _c.sea;
+                                    _this.saveCredentials({
+                                        alias: alias || normalizedUsername,
+                                        pair: pair !== null && pair !== void 0 ? pair : userPair,
+                                        userPub: userPub,
+                                    });
+                                    resolve(_this.buildLoginResult(alias || normalizedUsername, userPub));
+                                });
+                            })];
+                    case 2:
+                        loginResult = _a.sent();
+                        // If we got a successful result, return it
+                        if (loginResult && loginResult.success) {
+                            return [2 /*return*/, loginResult];
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        e_1 = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 4:
+                        console.log("[DB] Falling back to classic username/password account creation");
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                var callbackInvoked = false;
+                                var timeoutId = setTimeout(function () {
+                                    if (!callbackInvoked) {
+                                        callbackInvoked = true;
+                                        console.log("[DB] Signup timeout");
+                                        _this.resetAuthState();
+                                        resolve({ success: false, error: "Signup timeout" });
+                                    }
+                                }, CONFIG.TIMEOUT);
+                                user.create(normalizedUsername, password, function (createAck) {
+                                    if (callbackInvoked) {
+                                        return;
+                                    }
+                                    console.log("[DB] Signup callback received:", JSON.stringify(createAck));
+                                    // Check for error: ack.err or ack.ok !== 0 means error
+                                    if (createAck.err ||
+                                        (createAck.ok !== undefined && createAck.ok !== 0)) {
+                                        callbackInvoked = true;
+                                        clearTimeout(timeoutId);
+                                        _this.resetAuthState();
+                                        resolve({ success: false, error: createAck.err || "Signup failed" });
+                                        return;
+                                    }
+                                    // After create, we need to authenticate to get the user fully logged in
+                                    // Use ack.pub if available for the userPub
+                                    var userPub = createAck.pub;
+                                    if (!userPub) {
+                                        callbackInvoked = true;
+                                        clearTimeout(timeoutId);
+                                        _this.resetAuthState();
+                                        resolve({
+                                            success: false,
+                                            error: "No userPub available from signup",
+                                        });
+                                        return;
+                                    }
+                                    // Now authenticate with the username/password to complete the login
+                                    user.auth(normalizedUsername, password, function (authAck) {
+                                        var _a, _b, _c, _d;
+                                        if (callbackInvoked) {
+                                            return;
+                                        }
+                                        callbackInvoked = true;
+                                        clearTimeout(timeoutId);
+                                        if (authAck.err) {
+                                            _this.resetAuthState();
+                                            resolve({
+                                                success: false,
+                                                error: authAck.err || "Authentication after signup failed",
+                                            });
+                                            return;
+                                        }
+                                        // Verify user is authenticated
+                                        var authenticatedUserPub = (_a = user === null || user === void 0 ? void 0 : user.is) === null || _a === void 0 ? void 0 : _a.pub;
+                                        if (!authenticatedUserPub) {
+                                            _this.resetAuthState();
+                                            resolve({
+                                                success: false,
+                                                error: "User not authenticated after signup",
+                                            });
+                                            return;
+                                        }
+                                        _this.user = user;
+                                        var alias = (_b = user === null || user === void 0 ? void 0 : user.is) === null || _b === void 0 ? void 0 : _b.alias;
+                                        var userPair = (_c = user === null || user === void 0 ? void 0 : user._) === null || _c === void 0 ? void 0 : _c.sea;
+                                        try {
+                                            _this.saveCredentials({
+                                                alias: alias || normalizedUsername,
+                                                pair: pair !== null && pair !== void 0 ? pair : userPair,
+                                                userPub: authenticatedUserPub,
+                                            });
+                                        }
+                                        catch (saveError) {
+                                            // Ignore save errors
+                                        }
+                                        var sea = (_d = user === null || user === void 0 ? void 0 : user._) === null || _d === void 0 ? void 0 : _d.sea;
+                                        resolve({
+                                            success: true,
+                                            userPub: authenticatedUserPub,
+                                            username: normalizedUsername,
+                                            isNewUser: true,
+                                            sea: sea
+                                                ? {
+                                                    pub: sea.pub,
+                                                    priv: sea.priv,
+                                                    epub: sea.epub,
+                                                    epriv: sea.epriv,
+                                                }
+                                                : undefined,
+                                        });
+                                    });
+                                });
+                            })];
+                    case 5:
+                        result = _a.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /**
+     * Login with username and password
+     * Based on Gun.js user().auth() - https://deepwiki.com/amark/gun/6.1-user-authentication
+     */
+    DataBase.prototype.login = function (username, password, pair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalizedUsername, user;
+            var _this = this;
+            return __generator(this, function (_a) {
+                this.resetAuthState();
+                normalizedUsername = username.trim().toLowerCase();
+                user = this.gun.user();
+                console.log("[DB] Login with username:", normalizedUsername);
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var timeoutId = setTimeout(function () {
+                            _this.resetAuthState();
+                            resolve({ success: false, error: "Login timeout" });
+                        }, CONFIG.TIMEOUT);
+                        if (pair) {
+                            user.auth(pair, function (ack) {
+                                var _a, _b, _c;
+                                clearTimeout(timeoutId);
+                                if (ack.err) {
+                                    _this.resetAuthState();
+                                    resolve({ success: false, error: ack.err });
+                                    return;
+                                }
+                                var userPub = (_a = user === null || user === void 0 ? void 0 : user.is) === null || _a === void 0 ? void 0 : _a.pub;
+                                if (!userPub) {
+                                    _this.resetAuthState();
+                                    resolve({ success: false, error: "No userPub available" });
+                                    return;
+                                }
+                                _this.user = user;
+                                var alias = (_b = user === null || user === void 0 ? void 0 : user.is) === null || _b === void 0 ? void 0 : _b.alias;
+                                var userPair = (_c = user === null || user === void 0 ? void 0 : user._) === null || _c === void 0 ? void 0 : _c.sea;
+                                try {
+                                    _this.saveCredentials({
+                                        alias: alias || normalizedUsername,
+                                        pair: pair !== null && pair !== void 0 ? pair : userPair,
+                                        userPub: userPub,
+                                    });
+                                }
+                                catch (saveError) {
+                                    // Ignore save errors
+                                }
+                                resolve(_this.buildLoginResult(alias || normalizedUsername, userPub));
+                            });
+                        }
+                        else {
+                            user.auth(normalizedUsername, password, function (ack) {
+                                var _a, _b, _c;
+                                clearTimeout(timeoutId);
+                                if (ack.err) {
+                                    _this.resetAuthState();
+                                    resolve({ success: false, error: ack.err });
+                                    return;
+                                }
+                                var userPub = (_a = user === null || user === void 0 ? void 0 : user.is) === null || _a === void 0 ? void 0 : _a.pub;
+                                if (!userPub) {
+                                    _this.resetAuthState();
+                                    resolve({ success: false, error: "No userPub available" });
+                                    return;
+                                }
+                                _this.user = user;
+                                var alias = (_b = user === null || user === void 0 ? void 0 : user.is) === null || _b === void 0 ? void 0 : _b.alias;
+                                var userPair = (_c = user === null || user === void 0 ? void 0 : user._) === null || _c === void 0 ? void 0 : _c.sea;
+                                try {
+                                    _this.saveCredentials({
+                                        alias: alias || normalizedUsername,
+                                        pair: pair !== null && pair !== void 0 ? pair : userPair,
+                                        userPub: userPub,
+                                    });
+                                }
+                                catch (saveError) {
+                                    // Ignore save errors
+                                }
+                                resolve(_this.buildLoginResult(alias || normalizedUsername, userPub));
+                            });
+                        }
+                    })];
+            });
+        });
+    };
+    /**
+     * Get current user
+     */
+    DataBase.prototype.getCurrentUser = function () {
+        try {
+            var user = this.gun.user();
+            if (user && user.is && user.is.pub) {
+                return {
+                    pub: user.is.pub,
+                    user: user,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    /**
+     * Get current user's public key
+     * @returns {string | null} User's public key or null if not logged in
+     */
+    DataBase.prototype.getUserPub = function () {
+        var _a;
+        try {
+            var user = this.gun.user();
+            return ((_a = user === null || user === void 0 ? void 0 : user.is) === null || _a === void 0 ? void 0 : _a.pub) || null;
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    /**
+     * Login with SEA pair directly
+     * @param username - Username for identification
+     * @param pair - GunDB SEA pair for authentication
+     * @returns {Promise<AuthResult>} Promise with authentication result
+     * @description Authenticates user using a GunDB pair directly without password
+     */
+    DataBase.prototype.loginWithPair = function (username, pair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalizedUsername, user;
+            var _this = this;
+            return __generator(this, function (_a) {
+                // Validate pair structure
+                if (!pair || !pair.pub || !pair.priv || !pair.epub || !pair.epriv) {
+                    return [2 /*return*/, {
+                            success: false,
+                            error: "Invalid pair structure - missing required keys",
+                        }];
+                }
+                this.resetAuthState();
+                normalizedUsername = username.trim().toLowerCase();
+                user = this.gun.user();
+                console.log("[DB] Login with pair for username:", normalizedUsername);
+                return [2 /*return*/, new Promise(function (resolve) {
+                        var timeoutId = setTimeout(function () {
+                            _this.resetAuthState();
+                            resolve({ success: false, error: "Login with pair timeout" });
+                        }, CONFIG.TIMEOUT);
+                        user.auth(pair, function (ack) {
+                            var _a, _b, _c;
+                            clearTimeout(timeoutId);
+                            if (ack.err) {
+                                _this.resetAuthState();
+                                resolve({ success: false, error: ack.err });
+                                return;
+                            }
+                            var userPub = (_a = user === null || user === void 0 ? void 0 : user.is) === null || _a === void 0 ? void 0 : _a.pub;
+                            if (!userPub) {
+                                _this.resetAuthState();
+                                resolve({ success: false, error: "No userPub available" });
+                                return;
+                            }
+                            _this.user = user;
+                            var alias = (_b = user === null || user === void 0 ? void 0 : user.is) === null || _b === void 0 ? void 0 : _b.alias;
+                            var userPair = (_c = user === null || user === void 0 ? void 0 : user._) === null || _c === void 0 ? void 0 : _c.sea;
+                            try {
+                                _this.saveCredentials({
+                                    alias: alias || normalizedUsername,
+                                    pair: pair !== null && pair !== void 0 ? pair : userPair,
+                                    userPub: userPub,
+                                });
+                            }
+                            catch (saveError) {
+                                // Ignore save errors
+                            }
+                            resolve(_this.buildLoginResult(alias || normalizedUsername, userPub));
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     * Login with SEA pair
+     */
+    // Legacy method - kept for backward compatibility
+    DataBase.prototype.loginWithPairLegacy = function (username, pair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.login(username, "", pair)];
+            });
+        });
+    };
+    /**
+     * Get RxJS module
+     */
+    DataBase.prototype.rx = function () {
+        return this._rxjs;
+    };
+    /**
+     * Destroy database instance
+     */
+    DataBase.prototype.destroy = function () {
+        if (this._isDestroyed)
+            return;
+        console.log("[DB] Destroying DataBase instance...");
+        this._isDestroyed = true;
+        this.onAuthCallbacks.length = 0;
+        // Clear event listeners
+        this.eventEmitter.removeAllListeners();
+        if (this.user) {
+            try {
+                this.user.leave();
+            }
+            catch (error) {
+                // Ignore
+            }
+            this.user = null;
+        }
+        this._rxjs = undefined;
+        console.log("[DB] DataBase instance destroyed");
+    };
+    /**
+     * Aggressive auth cleanup (kept for compatibility with tests)
+     */
+    DataBase.prototype.aggressiveAuthCleanup = function () {
+        console.log("🧹 Performing aggressive auth cleanup...");
+        this.resetAuthState();
+        this.logout();
+        console.log("✓ Aggressive auth cleanup completed");
+    };
+    /**
+     * Event emitter methods for CoreInitializer compatibility
+     */
+    DataBase.prototype.on = function (event, listener) {
+        this.eventEmitter.on(event, listener);
+    };
+    DataBase.prototype.off = function (event, listener) {
+        this.eventEmitter.off(event, listener);
+    };
+    DataBase.prototype.once = function (event, listener) {
+        this.eventEmitter.once(event, listener);
+    };
+    DataBase.prototype.emit = function (event, data) {
+        return this.eventEmitter.emit(event, data);
+    };
+    return DataBase;
+}());
+export { DataBase, RxJS, crypto, GunErrors };
+export { default as derive } from "./derive.js";