shogun-core 2.0.4 → 3.0.1

package/dist/gundb/index.js

@@ -1,2 +1,6 @@
 // Export the main class
 export * from "./db";
+// Export improved types
+export * from "./types";
+// Export simplified API
+export * from "./simple-api";

package/dist/gundb/simple-api.js

@@ -0,0 +1,438 @@
+/**
+ * Simplified API layer to reduce complexity for common use cases
+ * Provides quick-start methods that wrap the full DataBase functionality
+ */
+import { DataBase } from "./db";
+/**
+ * Simple API wrapper that provides common operations with minimal complexity
+ */
+export class SimpleGunAPI {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Quick data operations - simplified interface
+     */
+    // Simple get - returns data directly or null
+    async get(path) {
+        try {
+            const result = await this.db.getData(path);
+            return result;
+        }
+        catch (error) {
+            console.warn(`Failed to get data from ${path}:`, error);
+            return null;
+        }
+    }
+    // Simple put - returns success boolean
+    async put(path, data) {
+        try {
+            const result = await this.db.put(path, data);
+            return result.success;
+        }
+        catch (error) {
+            console.warn(`Failed to put data to ${path}:`, error);
+            return false;
+        }
+    }
+    // Simple set - returns success boolean
+    async set(path, data) {
+        try {
+            const result = await this.db.set(path, data);
+            return result.success;
+        }
+        catch (error) {
+            console.warn(`Failed to set data to ${path}:`, error);
+            return false;
+        }
+    }
+    // Simple remove - returns success boolean
+    async remove(path) {
+        try {
+            const result = await this.db.remove(path);
+            return result.success;
+        }
+        catch (error) {
+            console.warn(`Failed to remove data from ${path}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Quick authentication - simplified interface
+     */
+    // Simple login - returns user info or null
+    async login(username, password) {
+        try {
+            const result = await this.db.login(username, password);
+            if (result.success && result.userPub) {
+                return {
+                    userPub: result.userPub,
+                    username: result.username || username,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn(`Login failed for ${username}:`, error);
+            return null;
+        }
+    }
+    // Simple signup - returns user info or null
+    async signup(username, password) {
+        try {
+            const result = await this.db.signUp(username, password);
+            if (result.success && result.userPub) {
+                return {
+                    userPub: result.userPub,
+                    username: result.username || username,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn(`Signup failed for ${username}:`, error);
+            return null;
+        }
+    }
+    // Simple logout
+    logout() {
+        this.db.logout();
+    }
+    // Simple check if logged in
+    isLoggedIn() {
+        return this.db.isLoggedIn();
+    }
+    /**
+     * Quick user data operations - simplified interface
+     */
+    // Simple user data get
+    async getUserData(path) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return null;
+            }
+            return (await this.db.getUserData(path));
+        }
+        catch (error) {
+            console.warn(`Failed to get user data from ${path}:`, error);
+            return null;
+        }
+    }
+    // Simple user data put
+    async putUserData(path, data) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return false;
+            }
+            await this.db.putUserData(path, data);
+            return true;
+        }
+        catch (error) {
+            console.warn(`Failed to put user data to ${path}:`, error);
+            return false;
+        }
+    }
+    // Simple user data set (alternative to put)
+    async setUserData(path, data) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return false;
+            }
+            // Use the user's gun instance directly for set operations
+            const user = this.db.getUser();
+            if (user && user.is) {
+                await new Promise((resolve, reject) => {
+                    user.get(path).set(data, (ack) => {
+                        if (ack.err) {
+                            reject(new Error(ack.err));
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.warn(`Failed to set user data to ${path}:`, error);
+            return false;
+        }
+    }
+    // Simple user data remove
+    async removeUserData(path) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return false;
+            }
+            const user = this.db.getUser();
+            if (user && user.is) {
+                await new Promise((resolve, reject) => {
+                    user.get(path).put(null, (ack) => {
+                        if (ack.err) {
+                            reject(new Error(ack.err));
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.warn(`Failed to remove user data from ${path}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Quick utility methods
+     */
+    // Get current user info
+    getCurrentUser() {
+        const user = this.db.getCurrentUser();
+        if (user) {
+            return {
+                pub: user.pub,
+                username: user.username,
+            };
+        }
+        return null;
+    }
+    // Check if user exists by alias
+    async userExists(alias) {
+        try {
+            const user = await this.db.getUserByAlias(alias);
+            return user !== null;
+        }
+        catch (error) {
+            console.warn(`Failed to check if user exists: ${alias}`, error);
+            return false;
+        }
+    }
+    // Get user by alias
+    async getUser(alias) {
+        try {
+            const user = await this.db.getUserByAlias(alias);
+            if (user) {
+                return {
+                    userPub: user.userPub,
+                    username: user.username,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn(`Failed to get user: ${alias}`, error);
+            return null;
+        }
+    }
+    /**
+     * Advanced user space operations
+     */
+    // Get all user data (returns user's entire data tree)
+    async getAllUserData() {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return null;
+            }
+            const user = this.db.getUser();
+            if (user && user.is) {
+                const userData = await new Promise((resolve, reject) => {
+                    user.once((data) => {
+                        resolve(data);
+                    });
+                });
+                return userData;
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn("Failed to get all user data:", error);
+            return null;
+        }
+    }
+    // Update user profile (common use case)
+    async updateProfile(profileData) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return false;
+            }
+            return await this.putUserData("profile", profileData);
+        }
+        catch (error) {
+            console.warn("Failed to update profile:", error);
+            return false;
+        }
+    }
+    // Get user profile
+    async getProfile() {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return null;
+            }
+            return await this.getUserData("profile");
+        }
+        catch (error) {
+            console.warn("Failed to get profile:", error);
+            return null;
+        }
+    }
+    // Save user settings
+    async saveSettings(settings) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return false;
+            }
+            return await this.putUserData("settings", settings);
+        }
+        catch (error) {
+            console.warn("Failed to save settings:", error);
+            return false;
+        }
+    }
+    // Get user settings
+    async getSettings() {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return null;
+            }
+            return await this.getUserData("settings");
+        }
+        catch (error) {
+            console.warn("Failed to get settings:", error);
+            return null;
+        }
+    }
+    // Save user preferences
+    async savePreferences(preferences) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return false;
+            }
+            return await this.putUserData("preferences", preferences);
+        }
+        catch (error) {
+            console.warn("Failed to save preferences:", error);
+            return false;
+        }
+    }
+    // Get user preferences
+    async getPreferences() {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return null;
+            }
+            return await this.getUserData("preferences");
+        }
+        catch (error) {
+            console.warn("Failed to get preferences:", error);
+            return null;
+        }
+    }
+    // Create a user collection (for storing multiple items)
+    async createCollection(collectionName, items) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return false;
+            }
+            return await this.putUserData(`collections/${collectionName}`, items);
+        }
+        catch (error) {
+            console.warn(`Failed to create collection ${collectionName}:`, error);
+            return false;
+        }
+    }
+    // Add item to collection
+    async addToCollection(collectionName, itemId, item) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return false;
+            }
+            return await this.putUserData(`collections/${collectionName}/${itemId}`, item);
+        }
+        catch (error) {
+            console.warn(`Failed to add item to collection ${collectionName}:`, error);
+            return false;
+        }
+    }
+    // Get collection
+    async getCollection(collectionName) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return null;
+            }
+            return await this.getUserData(`collections/${collectionName}`);
+        }
+        catch (error) {
+            console.warn(`Failed to get collection ${collectionName}:`, error);
+            return null;
+        }
+    }
+    // Remove item from collection
+    async removeFromCollection(collectionName, itemId) {
+        try {
+            if (!this.isLoggedIn()) {
+                console.warn("User not logged in");
+                return false;
+            }
+            return await this.removeUserData(`collections/${collectionName}/${itemId}`);
+        }
+        catch (error) {
+            console.warn(`Failed to remove item from collection ${collectionName}:`, error);
+            return false;
+        }
+    }
+}
+/**
+ * Factory function to create a simple API instance
+ */
+export function createSimpleAPI(db) {
+    return new SimpleGunAPI(db);
+}
+/**
+ * Quick start helper - creates a simple API with minimal configuration
+ */
+export class QuickStart {
+    db;
+    simpleAPI;
+    constructor(gunInstance, appScope = "shogun") {
+        this.db = new DataBase(gunInstance, appScope);
+        this.simpleAPI = new SimpleGunAPI(this.db);
+    }
+    // Initialize the database
+    async init() {
+        await this.db.initialize();
+    }
+    // Get the simple API
+    get api() {
+        return this.simpleAPI;
+    }
+    // Get the full database instance for advanced usage
+    get database() {
+        return this.db;
+    }
+}
+/**
+ * Global helper for quick setup
+ */
+export function quickStart(gunInstance, appScope) {
+    return new QuickStart(gunInstance, appScope);
+}

package/dist/index.js

@@ -1,10 +1,16 @@
 import { ShogunCore } from "./core";
 import { SEA, RxJS, crypto, derive, GunErrors, DataBase } from "./gundb/db";
+// Import Simple API and improved types
+import { SimpleGunAPI, QuickStart, quickStart, createSimpleAPI, } from "./gundb";
 // Import Gun as default export
 import Gun from "./gundb/db";
 export * from "./utils/errorHandler";
 export * from "./plugins";
 export * from "./interfaces/shogun";
-export { SEA, RxJS, crypto, derive, GunErrors, DataBase };
+// Export simplified configuration
+export * from "./config/simplified-config";
+export { SEA, RxJS, crypto, derive, GunErrors, DataBase, 
+// Simple API exports
+SimpleGunAPI, QuickStart, quickStart, createSimpleAPI, };
 export { Gun };
 export { ShogunCore };

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);
+                    },
+                };
+        }
+    }
+}