shogun-core 3.0.4 → 3.0.5

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/base.js

@@ -0,0 +1,47 @@
+import { EventEmitter } from "../utils/eventEmitter";
+/**
+ * Classe base per tutti i plugin di ShogunCore
+ * Fornisce funzionalità comuni e implementazione base dell'interfaccia ShogunPlugin
+ */
+export class BasePlugin extends EventEmitter {
+    /** Descrizione opzionale del plugin */
+    description;
+    /** Categoria del plugin */
+    _category;
+    /** Riferimento all'istanza di ShogunCore */
+    core = null;
+    /**
+     * Inizializza il plugin con un'istanza di ShogunCore
+     * @param core Istanza di ShogunCore
+     */
+    initialize(core) {
+        this.core = core;
+    }
+    /**
+     * Distrugge il plugin e libera le risorse
+     */
+    destroy() {
+        try {
+            // Emetti evento di distruzione
+            this.emit("destroyed", {
+                name: this.name,
+                version: this.version,
+            });
+            this.core = null;
+        }
+        catch (error) {
+            console.error(`[${this.name}] Error during plugin destruction:`, error);
+        }
+    }
+    /**
+     * Verifica che il plugin sia stato inizializzato prima di usare il core
+     * @throws Error se il plugin non è stato inizializzato
+     * @returns L'istanza di ShogunCore non null
+     */
+    assertInitialized() {
+        if (!this.core) {
+            throw new Error(`Plugin ${this.name} not initialized`);
+        }
+        return this.core;
+    }
+}

package/dist/plugins/index.js

@@ -0,0 +1,15 @@
+// Base plugin interface and types
+export { BasePlugin } from "./base";
+// WebAuthn plugin exports
+export { Webauthn } from "./webauthn/webauthn";
+export { WebauthnPlugin } from "./webauthn/webauthnPlugin";
+// Ethereum plugin exports
+export { Web3Connector } from "./web3/web3Connector";
+export { Web3ConnectorPlugin } from "./web3/web3ConnectorPlugin";
+// Bitcoin plugin exports
+export { NostrConnector } from "./nostr/nostrConnector";
+export { NostrConnectorPlugin } from "./nostr/nostrConnectorPlugin";
+// OAuth plugin exports
+export { OAuthConnector } from "./oauth/oauthConnector";
+export { OAuthPlugin } from "./oauth/oauthPlugin";
+export * from "./oauth/types";

package/dist/plugins/nostr/index.js

@@ -0,0 +1,4 @@
+export * from "./nostrConnectorPlugin";
+export * from "./nostrConnector";
+export * from "./nostrSigner";
+export * from "./types";