shogun-core 5.2.0 → 5.2.1

package/dist/config/simplified-config.js

@@ -0,0 +1,236 @@
+"use strict";
+/**
+ * Simplified configuration options to reduce complexity
+ * Provides sensible defaults and easy-to-use presets
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickConfig = exports.ConfigHelpers = exports.ShogunConfigBuilder = exports.ShogunPresets = void 0;
+/**
+ * Preset configurations for common use cases
+ */
+exports.ShogunPresets = {
+    /**
+     * Minimal configuration for simple apps
+     */
+    minimal: () => ({
+        gunOptions: {
+            peers: ["https://relay.shogun-eco.xyz/gun"],
+            localStorage: true,
+        },
+    }),
+    /**
+     * Development configuration with local storage
+     */
+    development: () => ({
+        gunOptions: {
+            peers: ["https://relay.shogun-eco.xyz/gun"],
+            localStorage: true,
+            radisk: false,
+        },
+        timeouts: {
+            login: 5000,
+            signup: 5000,
+            operation: 3000,
+        },
+    }),
+    /**
+     * Production configuration with multiple peers
+     */
+    production: (customPeers) => ({
+        gunOptions: {
+            peers: customPeers || [
+                "https://relay.shogun-eco.xyz/gun",
+                "https://peer.wallie.io/gun",
+            ],
+            localStorage: true,
+            radisk: true,
+        },
+        timeouts: {
+            login: 10000,
+            signup: 10000,
+            operation: 5000,
+        },
+    }),
+    /**
+     * Offline-first configuration
+     */
+    offline: () => ({
+        gunOptions: {
+            peers: [],
+            localStorage: true,
+            radisk: true,
+        },
+    }),
+    /**
+     * Web3-enabled configuration
+     */
+    web3: () => ({
+        gunOptions: {
+            peers: ["https://relay.shogun-eco.xyz/gun"],
+            localStorage: true,
+        },
+        web3: {
+            enabled: true,
+        },
+    }),
+    /**
+     * WebAuthn-enabled configuration
+     */
+    webauthn: () => ({
+        gunOptions: {
+            peers: ["https://relay.shogun-eco.xyz/gun"],
+            localStorage: true,
+        },
+        webauthn: {
+            enabled: true,
+            rpName: "My Shogun App",
+            rpId: window.location.hostname,
+        },
+    }),
+};
+/**
+ * Configuration builder for custom setups
+ */
+class ShogunConfigBuilder {
+    constructor() {
+        this.config = {};
+    }
+    /**
+     * Set Gun options
+     */
+    gunOptions(options) {
+        this.config.gunOptions = { ...this.config.gunOptions, ...options };
+        return this;
+    }
+    /**
+     * Add peers
+     */
+    peers(peerList) {
+        this.config.gunOptions = {
+            ...this.config.gunOptions,
+            peers: [...(this.config.gunOptions?.peers || []), ...peerList],
+        };
+        return this;
+    }
+    /**
+     * Enable WebAuthn
+     */
+    enableWebAuthn(rpName, rpId) {
+        this.config.webauthn = {
+            enabled: true,
+            rpName: rpName || "My App",
+            rpId: rpId || window.location.hostname,
+        };
+        return this;
+    }
+    /**
+     * Enable Web3
+     */
+    enableWeb3() {
+        this.config.web3 = { enabled: true };
+        return this;
+    }
+    /**
+     * Enable Nostr
+     */
+    enableNostr() {
+        this.config.nostr = { enabled: true };
+        return this;
+    }
+    /**
+     * Set timeouts
+     */
+    timeouts(timeouts) {
+        this.config.timeouts = { ...this.config.timeouts, ...timeouts };
+        return this;
+    }
+    /**
+     * Build the final configuration
+     */
+    build() {
+        return this.config;
+    }
+}
+exports.ShogunConfigBuilder = ShogunConfigBuilder;
+/**
+ * Helper functions for common configuration patterns
+ */
+exports.ConfigHelpers = {
+    /**
+     * Create a configuration for a specific environment
+     */
+    forEnvironment(env) {
+        switch (env) {
+            case "development":
+                return exports.ShogunPresets.development();
+            case "production":
+                return exports.ShogunPresets.production();
+            case "test":
+                return exports.ShogunPresets.offline();
+            default:
+                return exports.ShogunPresets.minimal();
+        }
+    },
+    /**
+     * Create a configuration with custom peers
+     */
+    withPeers(peers) {
+        return exports.ShogunPresets.production(peers);
+    },
+    /**
+     * Create a configuration for a specific use case
+     */
+    forUseCase(useCase) {
+        const baseConfig = exports.ShogunPresets.production();
+        switch (useCase) {
+            case "chat":
+                return {
+                    ...baseConfig,
+                    timeouts: { ...baseConfig.timeouts, operation: 2000 },
+                };
+            case "social":
+                return {
+                    ...baseConfig,
+                    webauthn: { enabled: true, rpName: "Social App" },
+                };
+            case "gaming":
+                return {
+                    ...baseConfig,
+                    timeouts: { ...baseConfig.timeouts, operation: 1000 },
+                };
+            case "finance":
+                return {
+                    ...baseConfig,
+                    webauthn: { enabled: true, rpName: "Finance App" },
+                    timeouts: { ...baseConfig.timeouts, login: 15000 },
+                };
+            default:
+                return baseConfig;
+        }
+    },
+};
+/**
+ * Quick configuration functions
+ */
+exports.QuickConfig = {
+    /**
+     * Minimal setup for quick testing
+     */
+    test: () => exports.ShogunPresets.minimal(),
+    /**
+     * Standard setup for most apps
+     */
+    standard: () => exports.ShogunPresets.production(),
+    /**
+     * Setup with WebAuthn for secure apps
+     */
+    secure: () => exports.ShogunPresets.webauthn(),
+    /**
+     * Setup with Web3 for crypto apps
+     */
+    crypto: () => exports.ShogunPresets.web3(),
+    /**
+     * Offline setup for local development
+     */
+    local: () => exports.ShogunPresets.offline(),
+};

package/dist/core.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShogunCore = void 0;
+const errorHandler_1 = require("./utils/errorHandler");
+// Import managers
+const PluginManager_1 = require("./managers/PluginManager");
+const AuthManager_1 = require("./managers/AuthManager");
+const EventManager_1 = require("./managers/EventManager");
+const CoreInitializer_1 = require("./managers/CoreInitializer");
+/**
+ * Main ShogunCore class - implements the IShogunCore interface
+ *
+ * This is the primary entry point for the Shogun SDK, providing access to:
+ * - Decentralized database (GunInstance)
+ * - Authentication methods (traditional, WebAuthn, MetaMask)
+ * - Plugin system for extensibility
+ * - RxJS integration for reactive programming
+ *
+ * @since 2.0.0
+ */
+class ShogunCore {
+    /**
+     * 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.
+     */
+    constructor(config) {
+        this._user = null;
+        this.config = config;
+        // Initialize managers
+        this.eventManager = new EventManager_1.EventManager();
+        this.pluginManager = new PluginManager_1.PluginManager(this);
+        this.authManager = new AuthManager_1.AuthManager(this);
+        this.coreInitializer = new CoreInitializer_1.CoreInitializer(this);
+        // Initialize async components
+        this.coreInitializer.initialize(config).catch((error) => {
+            if (typeof console !== "undefined" && console.warn) {
+                console.warn("Error during async initialization:", error);
+            }
+        });
+    }
+    /**
+     * Access to the Gun instance
+     * @returns The Gun instance
+     */
+    get gun() {
+        return this._gun;
+    }
+    /**
+     * Access to the current user
+     * @returns The current Gun user instance
+     */
+    get user() {
+        return this._user;
+    }
+    /**
+     * Gets the current user information
+     * @returns Current user object or null
+     */
+    getCurrentUser() {
+        if (!this.db) {
+            return null;
+        }
+        return this.db.getCurrentUser();
+    }
+    // *********************************************************************************************************
+    // 🔌 PLUGIN MANAGEMENT 🔌
+    // *********************************************************************************************************
+    /**
+     * Registers 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) {
+        this.pluginManager.register(plugin);
+    }
+    /**
+     * Unregisters a plugin from the Shogun SDK
+     * @param pluginName Name of the plugin to unregister
+     */
+    unregister(pluginName) {
+        this.pluginManager.unregister(pluginName);
+    }
+    /**
+     * 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) {
+        return this.pluginManager.getPlugin(name);
+    }
+    /**
+     * Get information about all registered plugins
+     * @returns Array of plugin information objects
+     */
+    getPluginsInfo() {
+        return this.pluginManager.getPluginsInfo();
+    }
+    /**
+     * Get the total number of registered plugins
+     * @returns Number of registered plugins
+     */
+    getPluginCount() {
+        return this.pluginManager.getPluginCount();
+    }
+    /**
+     * Check if all plugins are properly initialized
+     * @returns Object with initialization status for each plugin
+     */
+    getPluginsInitializationStatus() {
+        return this.pluginManager.getPluginsInitializationStatus();
+    }
+    /**
+     * Validate plugin system integrity
+     * @returns Object with validation results
+     */
+    validatePluginSystem() {
+        return this.pluginManager.validatePluginSystem();
+    }
+    /**
+     * Attempt to reinitialize failed plugins
+     * @returns Object with reinitialization results
+     */
+    reinitializeFailedPlugins() {
+        return this.pluginManager.reinitializeFailedPlugins();
+    }
+    /**
+     * Check plugin compatibility with current ShogunCore version
+     * @returns Object with compatibility information
+     */
+    checkPluginCompatibility() {
+        return this.pluginManager.checkPluginCompatibility();
+    }
+    /**
+     * Get comprehensive debug information about the plugin system
+     * @returns Complete plugin system debug information
+     */
+    getPluginSystemDebugInfo() {
+        return this.pluginManager.getPluginSystemDebugInfo();
+    }
+    /**
+     * 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.pluginManager.hasPlugin(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) {
+        return this.pluginManager.getPluginsByCategory(category);
+    }
+    /**
+     * 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) {
+        return this.authManager.getAuthenticationMethod(type);
+    }
+    // *********************************************************************************************************
+    // 🔐 ERROR HANDLER 🔐
+    // *********************************************************************************************************
+    /**
+     * Retrieve recent errors logged by the system
+     * @param count - Number of errors to retrieve (default: 10)
+     * @returns List of most recent errors
+     */
+    getRecentErrors(count = 10) {
+        return errorHandler_1.ErrorHandler.getRecentErrors(count);
+    }
+    // *********************************************************************************************************
+    // 🔐 AUTHENTICATION
+    // *********************************************************************************************************
+    /**
+     * 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.authManager.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() {
+        this.authManager.logout();
+    }
+    /**
+     * 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) {
+        return this.authManager.login(username, password, pair);
+    }
+    /**
+     * 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(username, pair) {
+        return this.authManager.loginWithPair(username, pair);
+    }
+    /**
+     * 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) {
+        return this.authManager.signUp(username, password, pair);
+    }
+    // 📢 EVENT EMITTER 📢
+    /**
+     * 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.eventManager.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.eventManager.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.eventManager.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.eventManager.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.eventManager.removeAllListeners(eventName);
+        return this;
+    }
+    /**
+     * 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.authManager.setAuthMethod(method);
+    }
+    /**
+     * Get the current authentication method
+     * @returns The current authentication method or undefined if not set
+     */
+    getAuthMethod() {
+        return this.authManager.getAuthMethod();
+    }
+    /**
+     * Saves the current user credentials to storage
+     */
+    async saveCredentials(credentials) {
+        try {
+            this.storage.setItem("userCredentials", JSON.stringify(credentials));
+        }
+        catch (error) {
+            if (typeof console !== "undefined" && console.warn) {
+                console.warn("Failed to save credentials to storage");
+            }
+            if (typeof console !== "undefined" && console.error) {
+                console.error(`Error saving credentials:`, error);
+            }
+        }
+    }
+    getIsLoggedIn() {
+        return !!(this.user && this.user.is);
+    }
+}
+exports.ShogunCore = ShogunCore;
+ShogunCore.API_VERSION = "^4.0.7";
+// Global declarations are handled in the original core.ts file
+// to avoid conflicts, we only set the window properties here
+if (typeof window !== "undefined") {
+    window.Shogun = (config) => {
+        return new ShogunCore(config);
+    };
+}
+exports.default = ShogunCore;

package/dist/crypto/asymmetric.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = exports.encrypt = exports.deserializePrivateKey = exports.deserializePublicKey = exports.generateKeyPair = void 0;
+const hashing_1 = require("./hashing");
+// RSA Key Generation and Encryption/Decryption Methods
+const generateKeyPair = async () => {
+    try {
+        const keyPair = await crypto.subtle.generateKey({
+            name: "RSA-OAEP",
+            modulusLength: 4096, // Can be 1024, 2048, or 4096
+            publicExponent: new Uint8Array([1, 0, 1]), // 65537 in bytes
+            hash: "SHA-256", // Can be "SHA-1", "SHA-256", "SHA-384", or "SHA-512"
+        }, true, // Whether the key is extractable
+        ["encrypt", "decrypt"]);
+        // Export keys to JWK format for storage/transmission
+        const publicKeyJWK = await crypto.subtle.exportKey("jwk", keyPair.publicKey);
+        const privateKeyJWK = await crypto.subtle.exportKey("jwk", keyPair.privateKey);
+        return {
+            publicKey: publicKeyJWK,
+            privateKey: privateKeyJWK,
+        };
+    }
+    catch (error) {
+        console.error("Error generating key pair:", error);
+        throw error;
+    }
+};
+exports.generateKeyPair = generateKeyPair;
+const deserializePublicKey = async (key) => {
+    try {
+        // If key is already a JWK object, use it directly
+        // If it's a string, parse it first
+        const jwkKey = typeof key === "string" ? JSON.parse(key) : key;
+        // Validate that required JWK properties exist
+        if (!jwkKey.kty) {
+            throw new Error('Invalid JWK: missing "kty" property');
+        }
+        const publicKey = await crypto.subtle.importKey("jwk", // Import format
+        jwkKey, // The key in JWK format
+        {
+            name: "RSA-OAEP", // Algorithm name
+            hash: "SHA-256", // Hash algorithm
+        }, true, // Extractable flag
+        ["encrypt"]);
+        return publicKey;
+    }
+    catch (error) {
+        console.error("Error deserializing public key:", error);
+        throw error;
+    }
+};
+exports.deserializePublicKey = deserializePublicKey;
+const deserializePrivateKey = async (key) => {
+    try {
+        // If key is already a JWK object, use it directly
+        // If it's a string, parse it first
+        const jwkKey = typeof key === "string" ? JSON.parse(key) : key;
+        // Validate that required JWK properties exist
+        if (!jwkKey.kty) {
+            throw new Error('Invalid JWK: missing "kty" property');
+        }
+        const privateKey = await crypto.subtle.importKey("jwk", // Import format
+        jwkKey, // The key in JWK format
+        {
+            name: "RSA-OAEP", // Algorithm name
+            hash: "SHA-256", // Hash algorithm
+        }, true, // Extractable flag
+        ["decrypt"]);
+        return privateKey;
+    }
+    catch (error) {
+        console.error("Error deserializing private key:", error);
+        throw error;
+    }
+};
+exports.deserializePrivateKey = deserializePrivateKey;
+const encrypt = async (message, publicKey) => {
+    const encodedMessage = new TextEncoder().encode(message);
+    const encrypted = await crypto.subtle.encrypt({
+        name: "RSA-OAEP",
+    }, publicKey, encodedMessage);
+    return (0, hashing_1.arrayBufferToBase64)(encrypted);
+};
+exports.encrypt = encrypt;
+const decrypt = async (encryptedMessage, privateKey) => {
+    const buffer = (0, hashing_1.base64ToArrayBuffer)(encryptedMessage);
+    try {
+        const decrypted = await crypto.subtle.decrypt({
+            name: "RSA-OAEP",
+        }, privateKey, buffer);
+        const message = new TextDecoder().decode(decrypted);
+        return message;
+    }
+    catch (error) {
+        console.error("Decryption error:", error);
+        throw new Error("Unable to decrypt message. Incorrect private key.");
+    }
+};
+exports.decrypt = decrypt;