shogun-core 3.0.4 → 3.0.6

package/dist/managers/AuthManager.js

@@ -0,0 +1,225 @@
+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

@@ -0,0 +1,227 @@
+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 { DataBase, RxJS, createGun, 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);
+        try {
+            if (config.gunInstance && config.gunOptions === undefined) {
+                console.log("Using provided Gun instance");
+                this.core._gun = config.gunInstance;
+            }
+            else if (config.gunOptions && config.gunInstance === undefined) {
+                console.log("Creating new Gun instance");
+                this.core._gun = createGun(config.gunOptions);
+            }
+            else {
+                throw new Error("!!! NO GUN INSTANCE OR GUN OPTIONS PROVIDED !!!");
+            }
+        }
+        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 || "");
+            // Note: user is a getter that returns _user, so we don't need to assign it
+        }
+        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

@@ -0,0 +1,67 @@
+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;
+    }
+}