shogun-core 2.0.4 → 3.0.1

package/dist/types/interfaces/plugin.d.ts

@@ -42,7 +42,7 @@ export interface PluginManager {
      * @returns Il plugin richiesto o undefined se non trovato
      * @template T Tipo del plugin o dell'interfaccia pubblica del plugin
      */
-    getPlugin<T>(name: string): T | undefined;
+    getPlugin<T = ShogunPlugin>(name: string): T | undefined;
     /**
      * Verifica se un plugin è registrato
      * @param name Nome del plugin da verificare
@@ -55,4 +55,108 @@ export interface PluginManager {
      * @returns Array di plugin della categoria specificata
      */
     getPluginsByCategory(category: PluginCategory): ShogunPlugin[];
+    /**
+     * Ottiene informazioni su tutti i plugin registrati
+     * @returns Array di oggetti con informazioni sui plugin
+     */
+    getPluginsInfo(): Array<{
+        name: string;
+        version: string;
+        category?: PluginCategory;
+        description?: string;
+    }>;
+    /**
+     * Ottiene il numero totale di plugin registrati
+     * @returns Numero di plugin registrati
+     */
+    getPluginCount(): number;
+    /**
+     * Verifica se tutti i plugin sono inizializzati correttamente
+     * @returns Oggetto con stato di inizializzazione per ogni plugin
+     */
+    getPluginsInitializationStatus(): Record<string, {
+        initialized: boolean;
+        error?: string;
+    }>;
+    /**
+     * Valida l'integrità del sistema di plugin
+     * @returns Oggetto con risultati della validazione
+     */
+    validatePluginSystem(): {
+        totalPlugins: number;
+        initializedPlugins: number;
+        failedPlugins: string[];
+        warnings: string[];
+    };
+    /**
+     * Tenta di reinizializzare i plugin falliti
+     * @returns Oggetto con risultati della reinizializzazione
+     */
+    reinitializeFailedPlugins(): {
+        success: string[];
+        failed: Array<{
+            name: string;
+            error: string;
+        }>;
+    };
+    /**
+     * Verifica la compatibilità dei plugin con la versione corrente di ShogunCore
+     * @returns Oggetto con informazioni sulla compatibilità
+     */
+    checkPluginCompatibility(): {
+        compatible: Array<{
+            name: string;
+            version: string;
+        }>;
+        incompatible: Array<{
+            name: string;
+            version: string;
+            reason: string;
+        }>;
+        unknown: Array<{
+            name: string;
+            version: string;
+        }>;
+    };
+    /**
+     * Ottiene informazioni complete di debug sul sistema di plugin
+     * @returns Informazioni complete di debug del sistema di plugin
+     */
+    getPluginSystemDebugInfo(): {
+        shogunCoreVersion: string;
+        totalPlugins: number;
+        plugins: Array<{
+            name: string;
+            version: string;
+            category?: PluginCategory;
+            description?: string;
+            initialized: boolean;
+            error?: string;
+        }>;
+        initializationStatus: Record<string, {
+            initialized: boolean;
+            error?: string;
+        }>;
+        validation: {
+            totalPlugins: number;
+            initializedPlugins: number;
+            failedPlugins: string[];
+            warnings: string[];
+        };
+        compatibility: {
+            compatible: Array<{
+                name: string;
+                version: string;
+            }>;
+            incompatible: Array<{
+                name: string;
+                version: string;
+                reason: string;
+            }>;
+            unknown: Array<{
+                name: string;
+                version: string;
+            }>;
+        };
+    };
 }

package/dist/types/interfaces/shogun.d.ts

@@ -1,10 +1,12 @@
-import { IGunInstance } from "gun/types";
+import { GunInstance, GunUserInstance } from "../gundb/types";
+import { ISEAPair } from "gun";
 import { ethers } from "ethers";
 import { ShogunError } from "../utils/errorHandler";
 import { DataBase } from "../gundb/db";
 import { RxJS } from "../gundb/rxjs";
 import { ShogunPlugin, PluginManager } from "./plugin";
 import { ShogunStorage } from "../storage/storage";
+import { ShogunEventMap } from "./events";
 /**
  * Standard plugin categories in ShogunCore
  */
@@ -37,7 +39,7 @@ export declare enum CorePlugins {
     /** OAuth plugin */
     OAuth = "oauth"
 }
-export type AuthMethod = "password" | "webauthn" | "web3" | "nostr" | "oauth" | "bitcoin" | "pair";
+export type AuthMethod = "password" | "webauthn" | "web3" | "nostr" | "oauth" | "pair";
 export interface AuthResult {
     success: boolean;
     error?: string;
@@ -112,28 +114,36 @@ export interface SignUpResult {
     };
 }
 export interface IShogunCore extends PluginManager {
-    gun: IGunInstance<any>;
+    gun: GunInstance;
+    user: GunUserInstance | null;
     db: DataBase;
     rx: RxJS;
     storage: ShogunStorage;
     config: ShogunCoreConfig;
     provider?: ethers.Provider;
     signer?: ethers.Signer;
-    on(eventName: string | symbol, listener: (...args: any[]) => void): any;
-    off(eventName: string | symbol, listener: (...args: any[]) => void): any;
-    once(eventName: string | symbol, listener: (...args: any[]) => void): any;
-    removeAllListeners(eventName?: string | symbol): any;
-    emit(eventName: string | symbol, ...args: any[]): boolean;
+    wallets?: Wallets;
+    pluginManager: any;
+    on<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
+    off<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
+    once<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): this;
+    removeAllListeners(eventName?: string | symbol): this;
+    emit<K extends keyof ShogunEventMap>(eventName: K, data?: ShogunEventMap[K] extends void ? never : ShogunEventMap[K]): boolean;
     getRecentErrors(count?: number): ShogunError[];
-    login(username: string, password: string): Promise<AuthResult>;
-    signUp(username: string, password: string, passwordConfirmation?: string): Promise<SignUpResult>;
+    login(username: string, password: string, pair?: ISEAPair | null): Promise<AuthResult>;
+    loginWithPair(pair: ISEAPair): Promise<AuthResult>;
+    signUp(username: string, password?: string, pair?: ISEAPair | null): Promise<SignUpResult>;
     getAuthenticationMethod(type: AuthMethod): any;
+    setAuthMethod(method: AuthMethod): void;
+    getAuthMethod(): AuthMethod | undefined;
     getCurrentUser(): {
         pub: string;
         user?: any;
     } | null;
+    getIsLoggedIn(): boolean;
     logout(): void;
     isLoggedIn(): boolean;
+    saveCredentials(credentials: any): Promise<void>;
 }
 /**
  * WebAuthn configuration
@@ -150,12 +160,8 @@ export interface WebauthnConfig {
  * Shogun SDK configuration
  */
 export interface ShogunCoreConfig {
-    gunInstance?: IGunInstance<any>;
-    authToken?: string;
-    scope?: string;
-    peers?: string[];
-    localStorage?: boolean;
-    radisk?: boolean;
+    gunInstance?: GunInstance;
+    gunOptions?: any;
     webauthn?: WebauthnConfig;
     web3?: {
         enabled?: boolean;

package/dist/types/managers/AuthManager.d.ts

@@ -0,0 +1,72 @@
+import { IShogunCore, AuthResult, SignUpResult, AuthMethod } from "../interfaces/shogun";
+import { ISEAPair } from "gun";
+/**
+ * Manages authentication operations for ShogunCore
+ */
+export declare class AuthManager {
+    private core;
+    private currentAuthMethod?;
+    constructor(core: IShogunCore);
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): void;
+    /**
+     * 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.
+     */
+    login(username: string, password: string, pair?: ISEAPair | null): Promise<AuthResult>;
+    /**
+     * 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.
+     */
+    loginWithPair(pair: ISEAPair): Promise<AuthResult>;
+    /**
+     * 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.
+     */
+    signUp(username: string, password?: string, pair?: ISEAPair | null): Promise<SignUpResult>;
+    /**
+     * 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: AuthMethod): void;
+    /**
+     * Get the current authentication method
+     * @returns The current authentication method or undefined if not set
+     */
+    getAuthMethod(): AuthMethod | undefined;
+    /**
+     * 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: AuthMethod): import("..").ShogunPlugin | {
+        login: (username: string, password: string) => Promise<AuthResult>;
+        signUp: (username: string, password: string, confirm?: string) => Promise<SignUpResult>;
+    } | undefined;
+}

package/dist/types/managers/CoreInitializer.d.ts

@@ -0,0 +1,40 @@
+import { IShogunCore, ShogunCoreConfig } from "../interfaces/shogun";
+/**
+ * Handles initialization of ShogunCore components
+ */
+export declare class CoreInitializer {
+    private core;
+    constructor(core: IShogunCore);
+    /**
+     * 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.
+     */
+    initialize(config: ShogunCoreConfig): Promise<void>;
+    /**
+     * Initialize Gun instance
+     */
+    private initializeGun;
+    /**
+     * Initialize Gun user
+     */
+    private initializeGunUser;
+    /**
+     * Setup Gun event forwarding
+     */
+    private setupGunEventForwarding;
+    /**
+     * Setup wallet derivation
+     */
+    private setupWalletDerivation;
+    /**
+     * Register built-in plugins based on configuration
+     */
+    private registerBuiltinPlugins;
+    /**
+     * Initialize async components
+     */
+    private initializeAsync;
+}

package/dist/types/managers/EventManager.d.ts

@@ -0,0 +1,49 @@
+import { ShogunEventEmitter, ShogunEventMap } from "../interfaces/events";
+/**
+ * Manages event operations for ShogunCore
+ */
+export declare class EventManager {
+    private eventEmitter;
+    constructor();
+    /**
+     * 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<K extends keyof ShogunEventMap>(eventName: K, data?: ShogunEventMap[K] extends void ? never : ShogunEventMap[K]): boolean;
+    /**
+     * 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<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): 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<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): 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<K extends keyof ShogunEventMap>(eventName: K, listener: ShogunEventMap[K] extends void ? () => void : (data: ShogunEventMap[K]) => void): 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?: string | symbol): this;
+    /**
+     * Get the underlying event emitter instance
+     * @returns The ShogunEventEmitter instance
+     */
+    getEventEmitter(): ShogunEventEmitter;
+}

package/dist/types/managers/PluginManager.d.ts

@@ -0,0 +1,145 @@
+import { ShogunPlugin } from "../interfaces/plugin";
+import { PluginCategory } from "../interfaces/shogun";
+import { IShogunCore } from "../interfaces/shogun";
+/**
+ * Manages plugin registration, validation, and lifecycle
+ */
+export declare class PluginManager {
+    private plugins;
+    private core;
+    constructor(core: IShogunCore);
+    /**
+     * 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: ShogunPlugin): void;
+    /**
+     * Unregister a plugin from the Shogun SDK
+     * @param name Name of the plugin to unregister
+     */
+    unregister(name: string): boolean;
+    /**
+     * 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<T = ShogunPlugin>(name: string): T | undefined;
+    /**
+     * Get information about all registered plugins
+     * @returns Array of plugin information objects
+     */
+    getPluginsInfo(): Array<{
+        name: string;
+        version: string;
+        category?: PluginCategory;
+        description?: string;
+    }>;
+    /**
+     * Get the total number of registered plugins
+     * @returns Number of registered plugins
+     */
+    getPluginCount(): number;
+    /**
+     * Check if all plugins are properly initialized
+     * @returns Object with initialization status for each plugin
+     */
+    getPluginsInitializationStatus(): Record<string, {
+        initialized: boolean;
+        error?: string;
+    }>;
+    /**
+     * Validate plugin system integrity
+     * @returns Object with validation results
+     */
+    validatePluginSystem(): {
+        totalPlugins: number;
+        initializedPlugins: number;
+        failedPlugins: string[];
+        warnings: string[];
+    };
+    /**
+     * Attempt to reinitialize failed plugins
+     * @returns Object with reinitialization results
+     */
+    reinitializeFailedPlugins(): {
+        success: string[];
+        failed: Array<{
+            name: string;
+            error: string;
+        }>;
+    };
+    /**
+     * Check plugin compatibility with current ShogunCore version
+     * @returns Object with compatibility information
+     */
+    checkPluginCompatibility(): {
+        compatible: Array<{
+            name: string;
+            version: string;
+        }>;
+        incompatible: Array<{
+            name: string;
+            version: string;
+            reason: string;
+        }>;
+        unknown: Array<{
+            name: string;
+            version: string;
+        }>;
+    };
+    /**
+     * Get comprehensive debug information about the plugin system
+     * @returns Complete plugin system debug information
+     */
+    getPluginSystemDebugInfo(): {
+        shogunCoreVersion: string;
+        totalPlugins: number;
+        plugins: Array<{
+            name: string;
+            version: string;
+            category?: PluginCategory;
+            description?: string;
+            initialized: boolean;
+            error?: string;
+        }>;
+        initializationStatus: Record<string, {
+            initialized: boolean;
+            error?: string;
+        }>;
+        validation: {
+            totalPlugins: number;
+            initializedPlugins: number;
+            failedPlugins: string[];
+            warnings: string[];
+        };
+        compatibility: {
+            compatible: Array<{
+                name: string;
+                version: string;
+            }>;
+            incompatible: Array<{
+                name: string;
+                version: string;
+                reason: string;
+            }>;
+            unknown: Array<{
+                name: string;
+                version: string;
+            }>;
+        };
+    };
+    /**
+     * 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: string): boolean;
+    /**
+     * Get all plugins of a specific category
+     * @param category Category of plugins to filter
+     * @returns Array of plugins in the specified category
+     */
+    getPluginsByCategory(category: PluginCategory): ShogunPlugin[];
+}

package/dist/types/migration-test.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Migration test file to verify that the refactored ShogunCore
+ * maintains the same public API as the original implementation
+ */
+/**
+ * Test function to verify API compatibility
+ */
+export declare function testApiCompatibility(): void;
+/**
+ * Test that the refactored implementation maintains the same static properties
+ */
+export declare function testStaticProperties(): void;
+/**
+ * Run all compatibility tests
+ */
+export declare function runCompatibilityTests(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shogun-core",
-  "version": "2.0.4",
+  "version": "3.0.1",
   "description": "SHOGUN CORE - Core library for Shogun Ecosystem",
   "main": "./dist/index.js",
   "module": "./dist/index.js",