shogun-core 2.0.3 → 3.0.0

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 { 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) {
+        if (config.gunOptions.authToken) {
+            restrictedPut(Gun, config.gunOptions.authToken);
+        }
+        try {
+            if (config.gunInstance) {
+                this.core._gun = config.gunInstance;
+            }
+            else {
+                this.core._gun = createGun(config.gunOptions);
+            }
+        }
+        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 {
+            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

@@ -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;
+    }
+}

package/dist/managers/PluginManager.js

@@ -0,0 +1,296 @@
+/**
+ * Manages plugin registration, validation, and lifecycle
+ */
+export class PluginManager {
+    plugins = new Map();
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    /**
+     * Register a plugin with the Shogun SDK
+     * @param plugin Plugin instance to register
+     * @throws Error if a plugin with the same name is already registered
+     */
+    register(plugin) {
+        try {
+            if (!plugin.name) {
+                if (typeof console !== "undefined" && console.error) {
+                    console.error("Plugin registration failed: Plugin must have a name");
+                }
+                return;
+            }
+            if (this.plugins.has(plugin.name)) {
+                if (typeof console !== "undefined" && console.warn) {
+                    console.warn(`Plugin "${plugin.name}" is already registered. Skipping.`);
+                }
+                return;
+            }
+            // Initialize plugin with core instance
+            plugin.initialize(this.core);
+            this.plugins.set(plugin.name, plugin);
+            this.core.emit("plugin:registered", {
+                name: plugin.name,
+                version: plugin.version || "unknown",
+                category: plugin._category || "unknown",
+            });
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error(`Error registering plugin "${plugin.name}":`, error);
+            }
+        }
+    }
+    /**
+     * Unregister a plugin from the Shogun SDK
+     * @param name Name of the plugin to unregister
+     */
+    unregister(name) {
+        try {
+            const plugin = this.plugins.get(name);
+            if (!plugin) {
+                if (typeof console !== "undefined" && console.warn) {
+                    console.warn(`Plugin "${name}" not found for unregistration`);
+                }
+                return false;
+            }
+            // Destroy plugin if it has a destroy method
+            if (typeof plugin.destroy === "function") {
+                try {
+                    plugin.destroy();
+                }
+                catch (destroyError) {
+                    if (typeof console !== "undefined" && console.error) {
+                        console.error(`Error destroying plugin "${name}":`, destroyError);
+                    }
+                }
+            }
+            this.plugins.delete(name);
+            this.core.emit("plugin:unregistered", {
+                name: plugin.name,
+            });
+            return true;
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.error) {
+                console.error(`Error unregistering plugin "${name}":`, error);
+            }
+            return false;
+        }
+    }
+    /**
+     * Retrieve a registered plugin by name
+     * @param name Name of the plugin
+     * @returns The requested plugin or undefined if not found
+     * @template T Type of the plugin or its public interface
+     */
+    getPlugin(name) {
+        if (!name || typeof name !== "string") {
+            if (typeof console !== "undefined" && console.warn) {
+                console.warn("Invalid plugin name provided to getPlugin");
+            }
+            return undefined;
+        }
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            if (typeof console !== "undefined" && console.warn) {
+                console.warn(`Plugin "${name}" not found`);
+            }
+            return undefined;
+        }
+        return plugin;
+    }
+    /**
+     * Get information about all registered plugins
+     * @returns Array of plugin information objects
+     */
+    getPluginsInfo() {
+        const pluginsInfo = [];
+        this.plugins.forEach((plugin) => {
+            pluginsInfo.push({
+                name: plugin.name,
+                version: plugin.version || "unknown",
+                category: plugin._category,
+                description: plugin.description,
+            });
+        });
+        return pluginsInfo;
+    }
+    /**
+     * Get the total number of registered plugins
+     * @returns Number of registered plugins
+     */
+    getPluginCount() {
+        return this.plugins.size;
+    }
+    /**
+     * Check if all plugins are properly initialized
+     * @returns Object with initialization status for each plugin
+     */
+    getPluginsInitializationStatus() {
+        const status = {};
+        this.plugins.forEach((plugin, name) => {
+            try {
+                // Verifica se il plugin ha un metodo per controllare l'inizializzazione
+                if (typeof plugin.assertInitialized === "function") {
+                    plugin.assertInitialized();
+                    status[name] = { initialized: true };
+                }
+                else {
+                    // Fallback: verifica se il plugin ha un riferimento al core
+                    status[name] = {
+                        initialized: !!plugin.core,
+                        error: !plugin.core
+                            ? "No core reference found"
+                            : undefined,
+                    };
+                }
+            }
+            catch (error) {
+                status[name] = {
+                    initialized: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+        return status;
+    }
+    /**
+     * Validate plugin system integrity
+     * @returns Object with validation results
+     */
+    validatePluginSystem() {
+        const status = this.getPluginsInitializationStatus();
+        const totalPlugins = Object.keys(status).length;
+        const initializedPlugins = Object.values(status).filter((s) => s.initialized).length;
+        const failedPlugins = Object.entries(status)
+            .filter(([_, s]) => !s.initialized)
+            .map(([name, _]) => name);
+        const warnings = [];
+        if (totalPlugins === 0) {
+            warnings.push("No plugins registered");
+        }
+        if (failedPlugins.length > 0) {
+            warnings.push(`Failed plugins: ${failedPlugins.join(", ")}`);
+        }
+        return {
+            totalPlugins,
+            initializedPlugins,
+            failedPlugins,
+            warnings,
+        };
+    }
+    /**
+     * Attempt to reinitialize failed plugins
+     * @returns Object with reinitialization results
+     */
+    reinitializeFailedPlugins() {
+        const status = this.getPluginsInitializationStatus();
+        const failedPlugins = Object.entries(status)
+            .filter(([_, s]) => !s.initialized)
+            .map(([name, _]) => name);
+        const success = [];
+        const failed = [];
+        failedPlugins.forEach((pluginName) => {
+            try {
+                const plugin = this.plugins.get(pluginName);
+                if (!plugin) {
+                    failed.push({ name: pluginName, error: "Plugin not found" });
+                    return;
+                }
+                // Reinizializza il plugin
+                plugin.initialize(this.core);
+                success.push(pluginName);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                failed.push({ name: pluginName, error: errorMessage });
+                if (typeof console !== "undefined" && console.error) {
+                    console.error(`[PluginManager] Failed to reinitialize plugin ${pluginName}:`, error);
+                }
+            }
+        });
+        return { success, failed };
+    }
+    /**
+     * Check plugin compatibility with current ShogunCore version
+     * @returns Object with compatibility information
+     */
+    checkPluginCompatibility() {
+        const compatible = [];
+        const incompatible = [];
+        const unknown = [];
+        this.plugins.forEach((plugin) => {
+            const pluginInfo = {
+                name: plugin.name,
+                version: plugin.version || "unknown",
+            };
+            // Verifica se il plugin ha informazioni di compatibilità
+            if (typeof plugin.getCompatibilityInfo === "function") {
+                try {
+                    const compatibilityInfo = plugin.getCompatibilityInfo();
+                    if (compatibilityInfo && compatibilityInfo.compatible) {
+                        compatible.push(pluginInfo);
+                    }
+                    else {
+                        incompatible.push({
+                            ...pluginInfo,
+                            reason: compatibilityInfo?.reason || "Unknown compatibility issue",
+                        });
+                    }
+                }
+                catch (error) {
+                    unknown.push(pluginInfo);
+                }
+            }
+            else {
+                // Se non ha informazioni di compatibilità, considera sconosciuto
+                unknown.push(pluginInfo);
+            }
+        });
+        return { compatible, incompatible, unknown };
+    }
+    /**
+     * Get comprehensive debug information about the plugin system
+     * @returns Complete plugin system debug information
+     */
+    getPluginSystemDebugInfo() {
+        const pluginsInfo = this.getPluginsInfo();
+        const initializationStatus = this.getPluginsInitializationStatus();
+        const plugins = pluginsInfo.map((info) => ({
+            ...info,
+            initialized: initializationStatus[info.name]?.initialized || false,
+            error: initializationStatus[info.name]?.error,
+        }));
+        return {
+            shogunCoreVersion: "^1.6.6",
+            totalPlugins: this.getPluginCount(),
+            plugins,
+            initializationStatus,
+            validation: this.validatePluginSystem(),
+            compatibility: this.checkPluginCompatibility(),
+        };
+    }
+    /**
+     * Check if a plugin is registered
+     * @param name Name of the plugin to check
+     * @returns true if the plugin is registered, false otherwise
+     */
+    hasPlugin(name) {
+        return this.plugins.has(name);
+    }
+    /**
+     * Get all plugins of a specific category
+     * @param category Category of plugins to filter
+     * @returns Array of plugins in the specified category
+     */
+    getPluginsByCategory(category) {
+        const result = [];
+        this.plugins.forEach((plugin) => {
+            if (plugin._category === category) {
+                result.push(plugin);
+            }
+        });
+        return result;
+    }
+}

package/dist/migration-test.js

@@ -0,0 +1,91 @@
+/**
+ * Migration test file to verify that the refactored ShogunCore
+ * maintains the same public API as the original implementation
+ */
+import { ShogunCore } from "./core";
+import { ShogunCore as OriginalShogunCore } from "./core";
+/**
+ * Test function to verify API compatibility
+ */
+export function testApiCompatibility() {
+    const config = {
+        gunOptions: {
+            peers: ["https://gunjs.herokuapp.com/gun"],
+        },
+    };
+    // Test that both implementations can be instantiated with the same config
+    const originalCore = new OriginalShogunCore(config);
+    const refactoredCore = new ShogunCore(config);
+    // Test that all public methods exist on both implementations
+    const publicMethods = [
+        // Plugin management
+        "register",
+        "unregister",
+        "getPlugin",
+        "getPluginsInfo",
+        "getPluginCount",
+        "getPluginsInitializationStatus",
+        "validatePluginSystem",
+        "reinitializeFailedPlugins",
+        "checkPluginCompatibility",
+        "getPluginSystemDebugInfo",
+        "hasPlugin",
+        "getPluginsByCategory",
+        "getAuthenticationMethod",
+        // Error handling
+        "getRecentErrors",
+        // Authentication
+        "isLoggedIn",
+        "logout",
+        "login",
+        "loginWithPair",
+        "signUp",
+        // Event management
+        "emit",
+        "on",
+        "once",
+        "off",
+        "removeAllListeners",
+        // Auth method management
+        "setAuthMethod",
+        "getAuthMethod",
+        // Storage
+        "saveCredentials",
+        "getIsLoggedIn",
+        // Getters
+        "getCurrentUser",
+    ];
+    const missingMethods = [];
+    publicMethods.forEach((method) => {
+        if (typeof refactoredCore[method] !== "function") {
+            missingMethods.push(method);
+        }
+    });
+    if (missingMethods.length > 0) {
+        throw new Error(`Missing methods in refactored implementation: ${missingMethods.join(", ")}`);
+    }
+    console.log("✅ API compatibility test passed - all public methods are present");
+}
+/**
+ * Test that the refactored implementation maintains the same static properties
+ */
+export function testStaticProperties() {
+    if (ShogunCore.API_VERSION !== OriginalShogunCore.API_VERSION) {
+        throw new Error("API_VERSION mismatch between implementations");
+    }
+    console.log("✅ Static properties test passed");
+}
+/**
+ * Run all compatibility tests
+ */
+export function runCompatibilityTests() {
+    try {
+        testStaticProperties();
+        testApiCompatibility();
+        console.log("🎉 All compatibility tests passed! The refactored implementation is ready.");
+    }
+    catch (error) {
+        console.error("❌ Compatibility test failed:", error);
+        throw error;
+    }
+}

package/dist/plugins/nostr/nostrConnectorPlugin.js

@@ -394,7 +394,7 @@ export class NostrConnectorPlugin extends BasePlugin {
             // Set authentication method to nostr before signup
             core.setAuthMethod("nostr");
             // Usa le chiavi derivate per signup
-            const signupResult = await core.signUp(credentials.username, "", "", k);
+            const signupResult = await core.signUp(credentials.username, undefined, k);
             if (signupResult.success) {
                 // Dopo la creazione, autentica subito
                 const authResult = await core.login(credentials.username, "", k);

package/dist/plugins/oauth/oauthPlugin.js

@@ -372,7 +372,7 @@ export class OAuthPlugin extends BasePlugin {
             return loginResult;
         }
         // If login fails, try signup
-        const signupResult = await this.core.signUp(username, "", "", k);
+        const signupResult = await this.core.signUp(username, undefined, k);
         if (signupResult.success) {
             // Immediately login after signup
             const postSignupLogin = await this.core.login(username, "", k);