shogun-core 3.0.3 → 3.0.4

package/dist/managers/AuthManager.js

@@ -1,225 +0,0 @@
-import { ErrorHandler, ErrorType } from "../utils/errorHandler";
-/**
- * Manages authentication operations for ShogunCore
- */
-export class AuthManager {
-    core;
-    currentAuthMethod;
-    constructor(core) {
-        this.core = core;
-    }
-    /**
-     * Check if user is logged in
-     * @returns {boolean} True if user is logged in, false otherwise
-     * @description Verifies authentication status by checking GunInstance login state
-     * and presence of authentication credentials in storage
-     */
-    isLoggedIn() {
-        return this.core.db.isLoggedIn();
-    }
-    /**
-     * Perform user logout
-     * @description Logs out the current user from GunInstance and emits logout event.
-     * If user is not authenticated, the logout operation is ignored.
-     */
-    logout() {
-        try {
-            if (!this.isLoggedIn()) {
-                return;
-            }
-            this.core.db.logout();
-            this.core.emit("auth:logout");
-        }
-        catch (error) {
-            ErrorHandler.handle(ErrorType.AUTHENTICATION, "LOGOUT_FAILED", error instanceof Error ? error.message : "Error during logout", error);
-        }
-    }
-    /**
-     * Authenticate user with username and password
-     * @param username - Username
-     * @param password - User password
-     * @returns {Promise<AuthResult>} Promise with authentication result
-     * @description Attempts to log in user with provided credentials.
-     * Emits login event on success.
-     */
-    async login(username, password, pair) {
-        try {
-            if (!this.currentAuthMethod) {
-                this.currentAuthMethod = "password";
-            }
-            const result = await this.core.db.login(username, password, pair);
-            if (result.success) {
-                // Include SEA pair in the response
-                const seaPair = this.core.user?._?.sea;
-                if (seaPair) {
-                    result.sea = seaPair;
-                }
-                this.core.emit("auth:login", {
-                    userPub: result.userPub ?? "",
-                    method: this.currentAuthMethod === "pair"
-                        ? "password"
-                        : this.currentAuthMethod || "password",
-                });
-            }
-            else {
-                result.error = result.error || "Wrong user or password";
-            }
-            return result;
-        }
-        catch (error) {
-            ErrorHandler.handle(ErrorType.AUTHENTICATION, "LOGIN_FAILED", error.message ?? "Unknown error during login", error);
-            return {
-                success: false,
-                error: error.message ?? "Unknown error during login",
-            };
-        }
-    }
-    /**
-     * Login with GunDB pair directly
-     * @param pair - GunDB SEA pair for authentication
-     * @returns {Promise<AuthResult>} Promise with authentication result
-     * @description Authenticates user using a GunDB pair directly.
-     * Emits login event on success.
-     */
-    async loginWithPair(pair) {
-        try {
-            if (!pair || !pair.pub || !pair.priv || !pair.epub || !pair.epriv) {
-                return {
-                    success: false,
-                    error: "Invalid pair structure - missing required keys",
-                };
-            }
-            // Use the new loginWithPair method from GunInstance
-            const result = await this.core.db.login("", "", pair);
-            if (result.success) {
-                // Include SEA pair in the response
-                const seaPair = this.core.user?._?.sea;
-                if (seaPair) {
-                    result.sea = seaPair;
-                }
-                this.currentAuthMethod = "pair";
-                this.core.emit("auth:login", {
-                    userPub: result.userPub ?? "",
-                    method: "password",
-                });
-            }
-            else {
-                result.error =
-                    result.error || "Authentication failed with provided pair";
-            }
-            return result;
-        }
-        catch (error) {
-            ErrorHandler.handle(ErrorType.AUTHENTICATION, "PAIR_LOGIN_FAILED", error.message ?? "Unknown error during pair login", error);
-            return {
-                success: false,
-                error: error.message ?? "Unknown error during pair login",
-            };
-        }
-    }
-    /**
-     * Register a new user with provided credentials
-     * @param username - Username
-     * @param password - Password
-     * @param email - Email (optional)
-     * @param pair - Pair of keys
-     * @returns {Promise<SignUpResult>} Registration result
-     * @description Creates a new user account with the provided credentials.
-     * Validates password requirements and emits signup event on success.
-     */
-    async signUp(username, password, pair) {
-        try {
-            if (!this.core.db) {
-                throw new Error("Database not initialized");
-            }
-            // For password-based signup, ensure password is provided
-            if (!pair && (!password || password.trim() === "")) {
-                throw new Error("Password is required for password-based signup");
-            }
-            const result = await this.core.db.signUp(username, password || "", pair);
-            if (result.success) {
-                // Update current authentication method
-                this.currentAuthMethod = pair ? "web3" : "password";
-                this.core.emit("auth:signup", {
-                    userPub: result.userPub,
-                    username,
-                    method: this.currentAuthMethod,
-                });
-                this.core.emit("debug", {
-                    action: "signup_success",
-                    userPub: result.userPub,
-                    method: this.currentAuthMethod,
-                });
-            }
-            else {
-                this.core.emit("debug", {
-                    action: "signup_failed",
-                    error: result.error,
-                    username,
-                });
-            }
-            return result;
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error(`Error during registration for user ${username}:`, error);
-            }
-            this.core.emit("debug", {
-                action: "signup_error",
-                error: error instanceof Error ? error.message : String(error),
-                username,
-            });
-            return {
-                success: false,
-                error: `Registration failed: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    /**
-     * Set the current authentication method
-     * This is used by plugins to indicate which authentication method was used
-     * @param method The authentication method used
-     */
-    setAuthMethod(method) {
-        this.currentAuthMethod = method;
-    }
-    /**
-     * Get the current authentication method
-     * @returns The current authentication method or undefined if not set
-     */
-    getAuthMethod() {
-        return this.currentAuthMethod;
-    }
-    /**
-     * Get an authentication method plugin by type
-     * @param type The type of authentication method
-     * @returns The authentication plugin or undefined if not available
-     * This is a more modern approach to accessing authentication methods
-     */
-    getAuthenticationMethod(type) {
-        switch (type) {
-            case "webauthn":
-                return this.core.getPlugin("WebAuthn");
-            case "web3":
-                return this.core.getPlugin("Web3");
-            case "nostr":
-                return this.core.getPlugin("Nostr");
-            case "oauth":
-                return this.core.getPlugin("OAuth");
-            case "password":
-            default:
-                return {
-                    login: async (username, password) => {
-                        return await this.login(username, password);
-                    },
-                    signUp: async (username, password, confirm) => {
-                        // For password-based signup, validate password confirmation
-                        if (confirm && password !== confirm) {
-                            throw new Error("Password and confirm password do not match");
-                        }
-                        return await this.signUp(username, password);
-                    },
-                };
-        }
-    }
-}

package/dist/managers/CoreInitializer.js

@@ -1,234 +0,0 @@
-import { ShogunStorage } from "../storage/storage";
-import { ErrorHandler } from "../utils/errorHandler";
-import { WebauthnPlugin } from "../plugins/webauthn/webauthnPlugin";
-import { Web3ConnectorPlugin } from "../plugins/web3/web3ConnectorPlugin";
-import { NostrConnectorPlugin } from "../plugins/nostr/nostrConnectorPlugin";
-import { OAuthPlugin } from "../plugins/oauth/oauthPlugin";
-import { restrictedPut, DataBase, RxJS, createGun, Gun, derive, } from "../gundb";
-/**
- * Handles initialization of ShogunCore components
- */
-export class CoreInitializer {
-    core;
-    constructor(core) {
-        this.core = core;
-    }
-    /**
-     * Initialize the Shogun SDK
-     * @param config - SDK Configuration object
-     * @description Creates a new instance of ShogunCore with the provided configuration.
-     * Initializes all required components including storage, event emitter, GunInstance connection,
-     * and plugin system.
-     */
-    async initialize(config) {
-        // Polyfill console for environments where it might be missing
-        if (typeof console === "undefined") {
-            global.console = {
-                log: () => { },
-                warn: () => { },
-                error: () => { },
-                info: () => { },
-                debug: () => { },
-            };
-        }
-        // Initialize storage
-        this.core.storage = new ShogunStorage();
-        // Setup error handler
-        ErrorHandler.addListener((error) => {
-            this.core.emit("error", {
-                action: error.code,
-                message: error.message,
-                type: error.type,
-            });
-        });
-        // Setup Gun instance
-        await this.initializeGun(config);
-        // Setup Gun user
-        await this.initializeGunUser();
-        // Setup Gun event forwarding
-        this.setupGunEventForwarding();
-        // Setup wallet derivation
-        this.setupWalletDerivation();
-        // Initialize RxJS
-        this.core.rx = new RxJS(this.core.gun);
-        // Register built-in plugins
-        this.registerBuiltinPlugins(config);
-        // Initialize async components
-        await this.initializeAsync();
-    }
-    /**
-     * Initialize Gun instance
-     */
-    async initializeGun(config) {
-        console.log("Initialize Gun instance", config);
-        if (config.gunOptions.authToken) {
-            restrictedPut(Gun, config.gunOptions.authToken);
-        }
-        try {
-            if (config.gunInstance && config.gunInstance instanceof Gun) {
-                console.log("config.gunInstance", config.gunInstance);
-                this.core._gun = config.gunInstance;
-            }
-            else {
-                console.log("config.gunOptions", config.gunOptions);
-                this.core._gun = createGun(config.gunOptions);
-                // Explicitly apply peers configuration if not already set
-                if (config.gunOptions?.peers &&
-                    Array.isArray(config.gunOptions.peers)) {
-                    console.log("Applying peers configuration:", config.gunOptions.peers);
-                    this.core._gun.opt({ peers: config.gunOptions.peers });
-                    console.log("Peers after explicit application:", this.core._gun?.opt?.peers);
-                }
-            }
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error creating Gun instance:", error);
-            }
-            throw new Error(`Failed to create Gun instance: ${error}`);
-        }
-        try {
-            console.log("Initialize Gun instance", this.core.gun);
-            this.core.db = new DataBase(this.core.gun, config.gunOptions.scope || "");
-            this.core._gun = this.core.db.gun;
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error initializing GunInstance:", error);
-            }
-            throw new Error(`Failed to initialize GunInstance: ${error}`);
-        }
-    }
-    /**
-     * Initialize Gun user
-     */
-    async initializeGunUser() {
-        try {
-            this.core._user = this.core.gun.user().recall({ sessionStorage: true });
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error initializing Gun user:", error);
-            }
-            throw new Error(`Failed to initialize Gun user: ${error}`);
-        }
-        this.core.gun.on("auth", (user) => {
-            this.core._user = this.core.gun.user().recall({ sessionStorage: true });
-            this.core.emit("auth:login", {
-                userPub: user.pub,
-                method: "password",
-            });
-        });
-    }
-    /**
-     * Setup Gun event forwarding
-     */
-    setupGunEventForwarding() {
-        const gunEvents = ["gun:put", "gun:get", "gun:set", "gun:remove"];
-        gunEvents.forEach((eventName) => {
-            this.core.db.on(eventName, (data) => {
-                this.core.emit(eventName, data);
-            });
-        });
-        const peerEvents = [
-            "gun:peer:add",
-            "gun:peer:remove",
-            "gun:peer:connect",
-            "gun:peer:disconnect",
-        ];
-        peerEvents.forEach((eventName) => {
-            this.core.db.on(eventName, (data) => {
-                this.core.emit(eventName, data);
-            });
-        });
-    }
-    /**
-     * Setup wallet derivation
-     */
-    setupWalletDerivation() {
-        this.core.gun.on("auth", async (user) => {
-            if (!user)
-                return;
-            const priv = user._?.sea?.epriv;
-            const pub = user._?.sea?.epub;
-            this.core.wallets = await derive(priv, pub, {
-                includeSecp256k1Bitcoin: true,
-                includeSecp256k1Ethereum: true,
-            });
-        });
-    }
-    /**
-     * Register built-in plugins based on configuration
-     */
-    registerBuiltinPlugins(config) {
-        try {
-            // Register OAuth plugin if configuration is provided
-            if (config.oauth) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn("OAuth plugin will be registered with provided configuration");
-                }
-                const oauthPlugin = new OAuthPlugin();
-                if (typeof oauthPlugin.configure === "function") {
-                    oauthPlugin.configure(config.oauth);
-                }
-                this.core.pluginManager.register(oauthPlugin);
-            }
-            // Register WebAuthn plugin if configuration is provided
-            if (config.webauthn) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn("WebAuthn plugin will be registered with provided configuration");
-                }
-                const webauthnPlugin = new WebauthnPlugin();
-                if (typeof webauthnPlugin.configure === "function") {
-                    webauthnPlugin.configure(config.webauthn);
-                }
-                this.core.pluginManager.register(webauthnPlugin);
-            }
-            // Register Web3 plugin if configuration is provided
-            if (config.web3) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn("Web3 plugin will be registered with provided configuration");
-                }
-                const web3Plugin = new Web3ConnectorPlugin();
-                if (typeof web3Plugin.configure === "function") {
-                    web3Plugin.configure(config.web3);
-                }
-                this.core.pluginManager.register(web3Plugin);
-            }
-            // Register Nostr plugin if configuration is provided
-            if (config.nostr) {
-                if (typeof console !== "undefined" && console.warn) {
-                    console.warn("Nostr plugin will be registered with provided configuration");
-                }
-                const nostrPlugin = new NostrConnectorPlugin();
-                if (typeof nostrPlugin.configure === "function") {
-                    nostrPlugin.configure(config.nostr);
-                }
-                this.core.pluginManager.register(nostrPlugin);
-            }
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error registering builtin plugins:", error);
-            }
-        }
-    }
-    /**
-     * Initialize async components
-     */
-    async initializeAsync() {
-        try {
-            await this.core.db.initialize();
-            this.core.emit("debug", {
-                action: "core_initialized",
-                timestamp: Date.now(),
-            });
-        }
-        catch (error) {
-            if (typeof console !== "undefined" && console.error) {
-                console.error("Error during Shogun Core initialization:", error);
-            }
-            throw error;
-        }
-    }
-}

package/dist/managers/EventManager.js

@@ -1,67 +0,0 @@
-import { ShogunEventEmitter } from "../interfaces/events";
-/**
- * Manages event operations for ShogunCore
- */
-export class EventManager {
-    eventEmitter;
-    constructor() {
-        this.eventEmitter = new ShogunEventEmitter();
-    }
-    /**
-     * Emits an event through the core's event emitter.
-     * Plugins should use this method to emit events instead of accessing the private eventEmitter directly.
-     * @param eventName The name of the event to emit.
-     * @param data The data to pass with the event.
-     * @returns {boolean} Indicates if the event had listeners.
-     */
-    emit(eventName, data) {
-        return this.eventEmitter.emit(eventName, data);
-    }
-    /**
-     * Add an event listener
-     * @param eventName The name of the event to listen for
-     * @param listener The callback function to execute when the event is emitted
-     * @returns {this} Returns this instance for method chaining
-     */
-    on(eventName, listener) {
-        this.eventEmitter.on(eventName, listener);
-        return this;
-    }
-    /**
-     * Add a one-time event listener
-     * @param eventName The name of the event to listen for
-     * @param listener The callback function to execute when the event is emitted
-     * @returns {this} Returns this instance for method chaining
-     */
-    once(eventName, listener) {
-        this.eventEmitter.once(eventName, listener);
-        return this;
-    }
-    /**
-     * Remove an event listener
-     * @param eventName The name of the event to stop listening for
-     * @param listener The callback function to remove
-     * @returns {this} Returns this instance for method chaining
-     */
-    off(eventName, listener) {
-        this.eventEmitter.off(eventName, listener);
-        return this;
-    }
-    /**
-     * Remove all listeners for a specific event or all events
-     * @param eventName Optional. The name of the event to remove listeners for.
-     * If not provided, all listeners for all events are removed.
-     * @returns {this} Returns this instance for method chaining
-     */
-    removeAllListeners(eventName) {
-        this.eventEmitter.removeAllListeners(eventName);
-        return this;
-    }
-    /**
-     * Get the underlying event emitter instance
-     * @returns The ShogunEventEmitter instance
-     */
-    getEventEmitter() {
-        return this.eventEmitter;
-    }
-}